diff --git a/generator/src/generator/namespace.rs b/generator/src/generator/namespace.rs index b0f6fdd7..7119dd9d 100644 --- a/generator/src/generator/namespace.rs +++ b/generator/src/generator/namespace.rs @@ -81,7 +81,10 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { outln!(out, "use crate::utils::RawFdContainer;"); outln!(out, "#[allow(unused_imports)]"); outln!(out, "use crate::x11_utils::{{Serialize, TryParse}};"); - outln!(out, "use crate::connection::RequestConnection;"); + outln!( + out, + "use crate::connection::{{BufWithFds, PiecewiseBuf, RequestConnection}};" + ); outln!(out, "#[allow(unused_imports)]"); outln!( out, @@ -209,14 +212,6 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { ) { let name = to_rust_type_name(&request_def.name); - outln!(out, "/// Opcode for the {} request", name); - outln!( - out, - "pub const {}_REQUEST: u8 = {};", - super::camel_case_to_upper_snake(&name), - request_def.opcode, - ); - let mut function_name = super::camel_case_to_lower_snake(&name); if function_name == "await" { function_name.push('_'); @@ -255,14 +250,9 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { let gathered = self.gather_request_fields(request_def, &deducible_fields); - self.emit_request_function( - request_def, - &name, - &function_name, - &deducible_fields, - &gathered, - out, - ); + self.emit_request_struct(request_def, &name, &deducible_fields, &gathered, out); + + self.emit_request_function(request_def, &name, &function_name, &gathered, out); self.emit_request_trait_function(request_def, &name, &function_name, &gathered, trait_out); special_cases::handle_request(request_def, out); @@ -374,131 +364,130 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { outln!(out, ""); } - fn emit_request_function( + fn emit_request_struct( &self, request_def: &xcbdefs::RequestDef, name: &str, - function_name: &str, deducible_fields: &FxHashMap, gathered: &GatheredRequestFields, out: &mut Output, ) { - let mut generic_params = String::new(); - if gathered.needs_lifetime { - generic_params.push_str("'c, Conn"); - } else { - generic_params.push_str("Conn"); - } - for (param_name, _) in gathered.generics.iter() { - generic_params.push_str(", "); - generic_params.push_str(param_name); - } - let ns = request_def.namespace.upgrade().unwrap(); - let is_send_event = request_def.name == "SendEvent" && ns.header == "xproto"; - let is_list_fonts_with_info = - request_def.name == "ListFontsWithInfo" && ns.header == "xproto"; - - let ret_lifetime = if gathered.needs_lifetime { "'c" } else { "'_" }; - let ret_type = if is_list_fonts_with_info { - assert!(request_def.reply.is_some()); - assert!(!gathered.reply_has_fds); - format!("ListFontsWithInfoCookie<{}, Conn>", ret_lifetime) - } else { - match (request_def.reply.is_some(), gathered.reply_has_fds) { - (false, _) => format!("VoidCookie<{}, Conn>", ret_lifetime), - (true, false) => format!("Cookie<{}, Conn, {}Reply>", ret_lifetime, name), - (true, true) => format!("CookieWithFds<{}, Conn, {}Reply>", ret_lifetime, name), - } - }; - let mut args = String::new(); - if gathered.needs_lifetime { - args.push_str("conn: &'c Conn"); - } else { - args.push_str("conn: &Conn"); - } - for (arg_name, arg_type) in gathered.args.iter() { - args.push_str(", "); - args.push_str(arg_name); - args.push_str(": "); - args.push_str(arg_type); - } + outln!(out, "/// Opcode for the {} request", name); + outln!( + out, + "pub const {}_REQUEST: u8 = {};", + super::camel_case_to_upper_snake(&name), + request_def.opcode, + ); if let Some(ref doc) = request_def.doc { self.emit_doc(doc, out); } + + let mut derives = Derives::all(); + self.filter_derives_for_fields(&mut derives, &request_def.fields.borrow()); + let derives = derives.to_list(); + if !derives.is_empty() { + outln!(out, "#[derive({})]", derives.join(", ")); + } + + let (struct_lifetime_block, serialize_lifetime_block) = if gathered.needs_lifetime { + ("<'input>", "") + } else { + ("", "'input, ") + }; + + let has_members = !gathered.request_args.is_empty(); + let members_start = if has_members { " {" } else { ";" }; outln!( out, - "pub fn {}<{}>({}) -> Result<{}, ConnectionError>", - function_name, - generic_params, - args, - ret_type, + "pub struct {name}Request{lifetime}{members_start}", + name = name, + lifetime = struct_lifetime_block, + members_start = members_start ); - outln!(out, "where"); - outln!(out.indent(), "Conn: RequestConnection + ?Sized,"); - for (param_name, where_) in gathered.generics.iter() { - outln!(out.indent(), "{}: {},", param_name, where_); - } - outln!(out, "{{"); - #[allow(clippy::cognitive_complexity)] out.indented(|out| { - if ns.ext_info.is_some() { - outln!( - out, - "let extension_information = conn.extension_information(X11_EXTENSION_NAME)?", - ); - outln!( - out.indent(), - ".ok_or(ConnectionError::UnsupportedExtension)?;" - ); - } - - for preamble in gathered.preamble.iter() { - outln!(out, "{}", preamble); + for (member_name, member_type) in gathered.request_args.iter() { + outln!(out, "pub {name}: {type},", + name=member_name, + type=member_type); } + }); + if has_members { + outln!(out, "}}",); + } - let fields = request_def.fields.borrow(); - - let has_expr_fields = fields.iter().any(|field| { - if let xcbdefs::FieldDef::Expr(_) = field { - true + // Methods implemented on every request + outln!( + out, + "impl{lifetime} {name}Request{lifetime} {{", + lifetime = struct_lifetime_block, + name = name + ); + out.indented(|out| { + outln!(out, "/// Serialize this request into bytes for the provided connection"); + outln!(out, "fn serialize<{lifetime}Conn>(self, conn: &Conn) -> Result>, ConnectionError>", + lifetime=serialize_lifetime_block); + outln!(out, "where"); + outln!(out.indent(), "Conn: RequestConnection + ?Sized,"); + outln!(out, "{{"); + out.indented(|out| { + if ns.ext_info.is_some() { + outln!( + out, + "let extension_information = conn.extension_information(X11_EXTENSION_NAME)?", + ); + outln!( + out.indent(), + ".ok_or(ConnectionError::UnsupportedExtension)?;" + ); } else { - false + // Silence a warning about an unused `conn`. + outln!(out, "let _ = conn;"); } - }); - // Calculate `VirtualLen` field values because they - // may be used by s. - if has_expr_fields { - for field in fields.iter() { - if let xcbdefs::FieldDef::VirtualLen(virtual_len_field) = field { - outln!( - out, - "let {} = u32::try_from({}.len()).unwrap();", - to_rust_variable_name(&virtual_len_field.name), - to_rust_variable_name(&virtual_len_field.list_name), - ); + + let fields = request_def.fields.borrow(); + + let has_expr_fields = fields.iter().any(|field| { + if let xcbdefs::FieldDef::Expr(_) = field { + true + } else { + false + } + }); + // Calculate `VirtualLen` field values because they + // may be used by s. + if has_expr_fields { + for field in fields.iter() { + if let xcbdefs::FieldDef::VirtualLen(virtual_len_field) = field { + outln!( + out, + "let {} = u32::try_from(self.{}.len()).unwrap();", + to_rust_variable_name(&virtual_len_field.name), + to_rust_variable_name(&virtual_len_field.list_name), + ); + } } } - } - outln!(out, "let length_so_far = 0;"); + outln!(out, "let length_so_far = 0;"); - let mut request_size = fields - .iter() - .try_fold(0, |sum, field| Some(sum + field.size()?)); + let mut request_size = fields + .iter() + .try_fold(0, |sum, field| Some(sum + field.size()?)); - let mut request_slices = Vec::new(); - let mut fixed_fields_bytes = Vec::new(); - let mut num_fixed_len_slices = 0; - let mut pad_count = 0; + let mut request_slices = Vec::new(); + let mut fixed_fields_bytes = Vec::new(); + let mut num_fixed_len_slices = 0; + let mut pad_count = 0; - for (field_i, field) in fields.iter().enumerate() { + for (field_i, field) in fields.iter().enumerate() { let mut next_slice = None; let mut tmp_out = Output::new(); - self.emit_assert_for_field_serialize(field, deducible_fields, "", &mut tmp_out); + self.emit_assert_for_field_serialize(field, deducible_fields, "self.", &mut tmp_out); match field { xcbdefs::FieldDef::Pad(pad_field) => match pad_field.kind { xcbdefs::PadKind::Bytes(bytes) => { @@ -516,7 +505,7 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { align, align, ); - next_slice = Some(format!("&padding{}", pad_count)); + next_slice = Some(format!("padding{}", pad_count)); pad_count += 1; } }, @@ -526,17 +515,12 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { fixed_fields_bytes .push(String::from("extension_information.major_opcode")); } else { - fixed_fields_bytes.push(format!( - "{}_REQUEST", - super::camel_case_to_upper_snake(name), - )); + fixed_fields_bytes.push(format!("{}_REQUEST", + super::camel_case_to_upper_snake(&name))); } } else if normal_field.name == "minor_opcode" { assert!(ns.ext_info.is_some()); - fixed_fields_bytes.push(format!( - "{}_REQUEST", - super::camel_case_to_upper_snake(name), - )); + fixed_fields_bytes.push(format!("{}_REQUEST", super::camel_case_to_upper_snake(&name))); } else if normal_field.name == "length" { // the actual length will be calculated later fixed_fields_bytes.push(String::from("0")); @@ -550,7 +534,7 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { self.emit_calc_deducible_field( field, deducible_field, - "", + "self.", &rust_field_name, out, ); @@ -561,13 +545,21 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { let bytes_name = postfix_var_name(&rust_field_name, "bytes"); if let Some(field_size) = normal_field.type_.size() { + let field_name = if was_deduced { + // If we deduced this value it comes from a local. + rust_field_name + } else { + // Otherwise a member. + format!("self.{}", rust_field_name) + }; + outln!( out, "let {} = {};", bytes_name, self.emit_value_serialize( &normal_field.type_, - &rust_field_name, + &field_name, was_deduced, ), ); @@ -577,11 +569,11 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { } else { outln!( tmp_out, - "let {} = {}.serialize();", + "let {} = self.{}.serialize();", bytes_name, - rust_field_name + rust_field_name, ); - next_slice = Some(format!("&{}", bytes_name)); + next_slice = Some(bytes_name); } } } @@ -589,15 +581,7 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { let rust_field_name = to_rust_variable_name(&list_field.name); let list_length = list_field.length(); if self.rust_value_type_is_u8(&list_field.element_type) { - if list_length.is_some() { - if is_send_event && list_field.name == "event" { - next_slice = Some(format!("&{}", rust_field_name)); - } else { - next_slice = Some(rust_field_name); - } - } else { - next_slice = Some(rust_field_name); - } + next_slice = Some(format!("(&self.{}[..])", rust_field_name)); } else { let element_size = list_field.element_type.size(); if let (Some(list_length), Some(element_size)) = @@ -625,11 +609,11 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { let bytes_name = postfix_var_name(&rust_field_name, "bytes"); outln!( tmp_out, - "let {} = {}.serialize();", + "let {} = self.{}.serialize();", bytes_name, rust_field_name, ); - next_slice = Some(format!("&{}", bytes_name)); + next_slice = Some(bytes_name); } else { let bytes_name = postfix_var_name(&rust_field_name, "bytes"); outln!(tmp_out, "let mut {} = Vec::new();", bytes_name); @@ -644,7 +628,7 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { ); }); outln!(tmp_out, "}}"); - next_slice = Some(format!("&{}", bytes_name)); + next_slice = Some(bytes_name); } } } @@ -653,12 +637,18 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { let bytes_name = postfix_var_name(&rust_field_name, "bytes"); outln!( tmp_out, - "let {} = {}.serialize({});", + "let {} = self.{}.serialize({});", bytes_name, rust_field_name, self.ext_params_to_call_args( false, - to_rust_variable_name, + |name| { + if deducible_fields.get(name).is_some() { + to_rust_variable_name(name) + } else { + format!("self.{}", to_rust_variable_name(name)) + } + }, &*switch_field.external_params.borrow(), ) ); @@ -667,7 +657,7 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { fixed_fields_bytes.push(format!("{}[{}]", bytes_name, i)); } } else { - next_slice = Some(format!("&{}", bytes_name)); + next_slice = Some(bytes_name); } } xcbdefs::FieldDef::Fd(_) => {} @@ -730,7 +720,7 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { } else { "" }; - outln!(out, "let {}request{} = [", maybe_mut, num_fixed_len_slices); + outln!(out, "let {}request{} = vec![", maybe_mut, num_fixed_len_slices); for byte in fixed_fields_bytes.iter() { outln!(out.indent(), "{},", byte); } @@ -740,128 +730,213 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { "let length_so_far = length_so_far + request{}.len();", num_fixed_len_slices, ); - request_slices.push(format!("&request{}", num_fixed_len_slices)); + request_slices.push(format!("request{}.into()", num_fixed_len_slices)); fixed_fields_bytes.clear(); num_fixed_len_slices += 1; } if let Some(next_slice) = next_slice { - let next_slice_for_len = if next_slice.starts_with('&') { - &next_slice[1..] - } else { - next_slice.as_str() - }; outln!( tmp_out, "let length_so_far = length_so_far + {}.len();", - next_slice_for_len, + next_slice, ); - request_slices.push(next_slice); + request_slices.push(format!("{}.into()", next_slice)); } } out!(out, "{}", tmp_out.into_data()); - } - - // The XML does not describe trailing padding in requests. Requests - // are implicitly padded to a four byte boundary. - if let Some(request_size) = request_size { - let req_size_rem = request_size % 4; - if req_size_rem != 0 { - assert_eq!(pad_count, 0); - outln!(out, "let padding = [0; {}];", 4 - req_size_rem); - outln!(out, "let length_so_far = length_so_far + padding.len();"); - request_slices.push(String::from("&padding")); } - } else { + // The XML does not describe trailing padding in requests. Requests + // are implicitly padded to a four byte boundary. + if let Some(request_size) = request_size { + let req_size_rem = request_size % 4; + if req_size_rem != 0 { + assert_eq!(pad_count, 0); + outln!(out, "let padding = [0; {}];", 4 - req_size_rem); + outln!(out, "let length_so_far = length_so_far + padding.len();"); + request_slices.push(String::from("(&padding).into()")); + } + } else { + outln!( + out, + "let padding{} = &[0; 3][..(4 - (length_so_far % 4)) % 4];", + pad_count, + ); + outln!( + out, + "let length_so_far = length_so_far + padding{}.len();", + pad_count, + ); + request_slices.push(format!("padding{}.into()", pad_count)); + } + + outln!(out, "assert_eq!(length_so_far % 4, 0);"); + // Set the length in the request. + // If it does not fit into u16, compute_length_field will use BigRequests. outln!( out, - "let padding{} = &[0; 3][..(4 - (length_so_far % 4)) % 4];", - pad_count, + "let length = u16::try_from(length_so_far / 4).unwrap_or(0);", ); outln!( out, - "let length_so_far = length_so_far + padding{}.len();", - pad_count, + "request0[2..4].copy_from_slice(&length.to_ne_bytes());", ); - request_slices.push(format!("&padding{}", pad_count)); - } - - outln!(out, "assert_eq!(length_so_far % 4, 0);"); - // Set the length in the request. - // If it does not fit into u16, compute_length_field will use BigRequests. - outln!( - out, - "let length = u16::try_from(length_so_far / 4).unwrap_or(0);", - ); - outln!( - out, - "request0[2..4].copy_from_slice(&length.to_ne_bytes());", - ); - let fds_arg = if gathered.fd_lists.is_empty() { - format!("vec![{}]", gathered.single_fds.join(", ")) - } else if gathered.fd_lists.len() == 1 && gathered.single_fds.is_empty() { - gathered.fd_lists[0].clone() - } else { - outln!(out, "let mut fds = Vec::new();"); - for field in fields.iter() { - match field { - xcbdefs::FieldDef::Fd(fd_field) => { - outln!(out, "fds.push({});", to_rust_variable_name(&fd_field.name)); - } - xcbdefs::FieldDef::FdList(fd_list_field) => { - outln!( - out, - "fds.extend({});", - to_rust_variable_name(&fd_list_field.name) - ); + let fds_arg = if gathered.fd_lists.is_empty() { + format!("vec![{}]", gathered.single_fds.iter().enumerate().map(|(i, single_fd)| { + let sep = if i == 0 { + "" + } else { + ", " + }; + format!("{}self.{}", sep, single_fd) + }).collect::()) + } else if gathered.fd_lists.len() == 1 && gathered.single_fds.is_empty() { + format!("self.{}", gathered.fd_lists[0]) + } else { + outln!(out, "let mut fds = Vec::new();"); + for field in fields.iter() { + match field { + xcbdefs::FieldDef::Fd(fd_field) => { + outln!(out, "fds.push({});", to_rust_variable_name(&fd_field.name)); + } + xcbdefs::FieldDef::FdList(fd_list_field) => { + outln!( + out, + "fds.extend({});", + to_rust_variable_name(&fd_list_field.name) + ); + } + _ => {} } - _ => {} } + String::from("fds") + }; + + let mut slices_arg = String::new(); + for (i, request_slices) in request_slices.iter().enumerate() { + if i != 0 { + slices_arg.push_str(", "); + } + slices_arg.push_str(request_slices); } - String::from("fds") - }; - let mut slices_arg = String::new(); - for (i, request_slices) in request_slices.iter().enumerate() { - if i != 0 { - slices_arg.push_str(", "); + outln!(out, "Ok((vec![{slices}], {fds}))", slices=slices_arg, fds=fds_arg); + }); + outln!(out, "}}"); + }); + outln!(out, "}}",); + } + + fn emit_request_function( + &self, + request_def: &xcbdefs::RequestDef, + name: &str, + function_name: &str, + gathered: &GatheredRequestFields, + out: &mut Output, + ) { + let ns = request_def.namespace.upgrade().unwrap(); + let is_list_fonts_with_info = + request_def.name == "ListFontsWithInfo" && ns.header == "xproto"; + let is_send_event = request_def.name == "SendEvent" && ns.header == "xproto"; + + let needs_lifetime = gathered.needs_lifetime && !is_send_event; + + let mut generic_params = String::new(); + if needs_lifetime { + generic_params.push_str("'c, 'input, Conn"); + } else { + generic_params.push_str("Conn"); + } + for (param_name, _) in gathered.generics.iter() { + generic_params.push_str(", "); + generic_params.push_str(param_name); + } + + let ret_lifetime = if needs_lifetime { "'c" } else { "'_" }; + let ret_type = if is_list_fonts_with_info { + assert!(request_def.reply.is_some()); + assert!(!gathered.reply_has_fds); + format!("ListFontsWithInfoCookie<{}, Conn>", ret_lifetime) + } else { + match (request_def.reply.is_some(), gathered.reply_has_fds) { + (false, _) => format!("VoidCookie<{}, Conn>", ret_lifetime), + (true, false) => format!("Cookie<{}, Conn, {}Reply>", ret_lifetime, name), + (true, true) => format!("CookieWithFds<{}, Conn, {}Reply>", ret_lifetime, name), + } + }; + + let mut args = String::new(); + if needs_lifetime { + args.push_str("conn: &'c Conn"); + } else { + args.push_str("conn: &Conn"); + } + for (arg_name, arg_type) in gathered.args.iter() { + args.push_str(", "); + args.push_str(arg_name); + args.push_str(": "); + args.push_str(arg_type); + } + + if let Some(ref doc) = request_def.doc { + self.emit_doc(doc, out); + } + outln!( + out, + "pub fn {}<{}>({}) -> Result<{}, ConnectionError>", + function_name, + generic_params, + args, + ret_type, + ); + outln!(out, "where"); + outln!(out.indent(), "Conn: RequestConnection + ?Sized,"); + for (param_name, where_) in gathered.generics.iter() { + outln!(out.indent(), "{}: {},", param_name, where_); + } + outln!(out, "{{"); + #[allow(clippy::cognitive_complexity)] + out.indented(|out| { + for preamble in gathered.preamble.iter() { + outln!(out, "{}", preamble); + } + + let has_members = !gathered.request_args.is_empty(); + let members_start = if has_members { " {" } else { ";" }; + outln!(out, "let request0 = {}Request{}", name, members_start); + out.indented(|out| { + for (arg_name, _) in gathered.args.iter() { + outln!(out, "{},", arg_name); } - slices_arg.push_str("IoSlice::new("); - slices_arg.push_str(request_slices); - slices_arg.push(')'); + }); + if has_members { + outln!(out, "}};"); } + outln!(out, "let (bytes, fds) = request0.serialize(conn)?;"); + outln!( + out, + "let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>();" + ); + if is_list_fonts_with_info { outln!( out, - "Ok(ListFontsWithInfoCookie::new(conn.send_request_with_reply(&[{}], {})?))", - slices_arg, - fds_arg, + "Ok(ListFontsWithInfoCookie::new(conn.send_request_with_reply(&slices, fds)?))", ) } else if request_def.reply.is_some() { if gathered.reply_has_fds { outln!( out, - "Ok(conn.send_request_with_reply_with_fds(&[{}], {})?)", - slices_arg, - fds_arg, + "Ok(conn.send_request_with_reply_with_fds(&slices, fds)?)", ); } else { - outln!( - out, - "Ok(conn.send_request_with_reply(&[{}], {})?)", - slices_arg, - fds_arg, - ); + outln!(out, "Ok(conn.send_request_with_reply(&slices, fds)?)",); } } else { - outln!( - out, - "Ok(conn.send_request_without_reply(&[{}], {})?)", - slices_arg, - fds_arg - ); + outln!(out, "Ok(conn.send_request_without_reply(&slices, fds)?)",); } }); outln!(out, "}}"); @@ -875,14 +950,20 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { gathered: &GatheredRequestFields, out: &mut Output, ) { + let ns = request_def.namespace.upgrade().unwrap(); + let is_list_fonts_with_info = + request_def.name == "ListFontsWithInfo" && ns.header == "xproto"; + let is_send_event = request_def.name == "SendEvent" && ns.header == "xproto"; + let needs_lifetime = gathered.needs_lifetime && !is_send_event; + let mut generic_params = String::new(); - if gathered.needs_lifetime || !gathered.generics.is_empty() { + if needs_lifetime || !gathered.generics.is_empty() { generic_params.push('<'); - if gathered.needs_lifetime { - generic_params.push_str("'c"); + if needs_lifetime { + generic_params.push_str("'c, 'input"); } for (i, (param_name, _)) in gathered.generics.iter().enumerate() { - if i != 0 || gathered.needs_lifetime { + if i != 0 || needs_lifetime { generic_params.push_str(", "); } generic_params.push_str(param_name); @@ -890,11 +971,7 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { generic_params.push('>'); } - let ns = request_def.namespace.upgrade().unwrap(); - let is_list_fonts_with_info = - request_def.name == "ListFontsWithInfo" && ns.header == "xproto"; - - let ret_lifetime = if gathered.needs_lifetime { "'c" } else { "'_" }; + let ret_lifetime = if needs_lifetime { "'c" } else { "'_" }; let ret_type = if is_list_fonts_with_info { assert!(request_def.reply.is_some()); assert!(!gathered.reply_has_fds); @@ -908,7 +985,7 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { }; let mut args = String::new(); - if gathered.needs_lifetime { + if needs_lifetime { args.push_str("&'c self"); } else { args.push_str("&self"); @@ -920,7 +997,6 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { args.push_str(arg_type); } - let ns = request_def.namespace.upgrade().unwrap(); let func_name_prefix = if ns.ext_info.is_some() { format!("{}_", ns.header) } else { @@ -4351,14 +4427,15 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { let mut needs_lifetime = false; let mut args = Vec::new(); + let mut request_args = Vec::new(); let mut generics = Vec::new(); let mut preamble = Vec::new(); let mut single_fds = Vec::new(); let mut fd_lists = Vec::new(); let ns = request_def.namespace.upgrade().unwrap(); - let is_change_propery = request_def.name == "ChangeProperty" && ns.header == "xproto"; - let is_get_propery = request_def.name == "GetProperty" && ns.header == "xproto"; + let is_change_property = request_def.name == "ChangeProperty" && ns.header == "xproto"; + let is_get_property = request_def.name == "GetProperty" && ns.header == "xproto"; let is_send_event = request_def.name == "SendEvent" && ns.header == "xproto"; for field in request_def.fields.borrow().iter() { @@ -4375,9 +4452,9 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { xcbdefs::FieldDef::Normal(normal_field) => { let rust_field_name = to_rust_variable_name(&normal_field.name); let rust_field_type = self.field_value_type_to_rust_type(&normal_field.type_); - let use_into = if ((is_change_propery || is_get_propery) + let use_into = if ((is_change_property || is_get_property) && normal_field.name == "property") - || (is_change_propery && normal_field.name == "type") + || (is_change_property && normal_field.name == "type") { true } else if self.use_enum_type_in_field(&normal_field.type_).is_none() { @@ -4396,36 +4473,44 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { ); let generic_param = format!("{}", char::from(letter_iter.next().unwrap())); let where_ = format!("Into<{}>", rust_field_type); - args.push((rust_field_name, generic_param.clone())); + args.push((rust_field_name.clone(), generic_param.clone())); + request_args.push((rust_field_name, rust_field_type)); generics.push((generic_param, where_)); preamble.push(preamble_part); } else { - args.push((rust_field_name, rust_field_type)); + args.push((rust_field_name.clone(), rust_field_type.clone())); + request_args.push((rust_field_name, rust_field_type)); } } xcbdefs::FieldDef::List(list_field) => { if is_send_event && list_field.name == "event" { let generic_param = format!("{}", char::from(letter_iter.next().unwrap())); args.push((list_field.name.clone(), generic_param.clone())); + request_args.push((list_field.name.clone(), "&'input [u8; 32]".into())); generics.push((generic_param, String::from("Into<[u8; 32]>"))); preamble.push(String::from("let event: [u8; 32] = event.into();")); + preamble.push(String::from("let event = &event;")); + needs_lifetime = true; } else { let element_type = self.field_value_type_to_rust_type(&list_field.element_type); let rust_field_name = to_rust_variable_name(&list_field.name); let rust_field_type = if let Some(list_len) = list_field.length() { - format!("&[{}; {}]", element_type, list_len) + format!("&'input [{}; {}]", element_type, list_len) } else { - format!("&[{}]", element_type) + format!("&'input [{}]", element_type) }; - args.push((rust_field_name, rust_field_type)); + args.push((rust_field_name.clone(), rust_field_type.clone())); + request_args.push((rust_field_name, rust_field_type)); needs_lifetime = true; } } xcbdefs::FieldDef::Switch(switch_field) => { let rust_field_name = to_rust_variable_name(&switch_field.name); - let rust_field_type = format!("&{}Aux", to_rust_type_name(&request_def.name)); - args.push((rust_field_name, rust_field_type)); + let rust_field_type = + format!("&'input {}Aux", to_rust_type_name(&request_def.name)); + args.push((rust_field_name.clone(), rust_field_type.clone())); + request_args.push((rust_field_name, rust_field_type)); needs_lifetime = true; } xcbdefs::FieldDef::Fd(fd_field) => { @@ -4435,14 +4520,16 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { "let {}: RawFdContainer = {}.into();", rust_field_name, rust_field_name, ); - args.push((rust_field_name, generic_param.clone())); + args.push((rust_field_name.clone(), generic_param.clone())); + request_args.push((rust_field_name, "RawFdContainer".into())); generics.push((generic_param, "Into".into())); preamble.push(preamble_part); single_fds.push(fd_field.name.clone()); } xcbdefs::FieldDef::FdList(fd_list_field) => { let rust_field_name = to_rust_variable_name(&fd_list_field.name); - args.push((rust_field_name, "Vec".into())); + args.push((rust_field_name.clone(), "Vec".into())); + request_args.push((rust_field_name, "Vec".into())); fd_lists.push(fd_list_field.name.clone()); } xcbdefs::FieldDef::Expr(_) => unreachable!(), @@ -4462,10 +4549,12 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { }) .unwrap_or(false); + assert_eq!(args.len(), request_args.len()); GatheredRequestFields { reply_has_fds, needs_lifetime, args, + request_args, generics, preamble, single_fds, @@ -4736,8 +4825,9 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> { derives.eq = false; } xcbdefs::TypeRef::EventStruct(_) => { - // Only appears in requests - unreachable!(); + // Event structs don't support equality tests. + derives.partial_eq = false; + derives.eq = false; } xcbdefs::TypeRef::Xid(_) => {} xcbdefs::TypeRef::XidUnion(_) => {} @@ -4999,12 +5089,18 @@ fn gather_deducible_fields(fields: &[xcbdefs::FieldDef]) -> FxHashMap, + /// Request arguments + /// The type here has been converted as necessary. + /// `(name, type)` + request_args: Vec<(String, String)>, /// Generic type parameters /// /// `(name, where clause)` diff --git a/src/connection.rs b/src/connection.rs index f2fab23b..924d6099 100644 --- a/src/connection.rs +++ b/src/connection.rs @@ -40,6 +40,7 @@ //! | Get | `Cookie::reply` | `Cookie::reply_unchecked` | //! | Ignore | `Cookie::discard_reply_and_errors` | Just drop the cookie | +use std::borrow::Cow; use std::convert::{TryFrom, TryInto}; use std::io::IoSlice; @@ -63,6 +64,7 @@ pub type SequenceNumber = u64; pub type BufWithFds = (B, Vec); pub type EventAndSeqNumber = (Event, SequenceNumber); pub type RawEventAndSeqNumber = (B, SequenceNumber); +pub type PiecewiseBuf<'a> = Vec>; /// Either a raw reply or a raw error response to an X11 request. #[derive(Debug)] diff --git a/src/protocol/bigreq.rs b/src/protocol/bigreq.rs index 55431e07..8f6da349 100644 --- a/src/protocol/bigreq.rs +++ b/src/protocol/bigreq.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -34,24 +34,38 @@ pub const X11_XML_VERSION: (u32, u32) = (0, 0); /// Opcode for the Enable request pub const ENABLE_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct EnableRequest; +impl EnableRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + ENABLE_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn enable(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - ENABLE_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = EnableRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] diff --git a/src/protocol/composite.rs b/src/protocol/composite.rs index be1dd1c9..f4b068c4 100644 --- a/src/protocol/composite.rs +++ b/src/protocol/composite.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -106,34 +106,54 @@ impl TryFrom for Redirect { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub client_major_version: u32, + pub client_minor_version: u32, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_version_bytes = self.client_major_version.serialize(); + let client_minor_version_bytes = self.client_minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + client_major_version_bytes[0], + client_major_version_bytes[1], + client_major_version_bytes[2], + client_major_version_bytes[3], + client_minor_version_bytes[0], + client_minor_version_bytes[1], + client_minor_version_bytes[2], + client_minor_version_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, client_major_version: u32, client_minor_version: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_version_bytes = client_major_version.serialize(); - let client_minor_version_bytes = client_minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - client_major_version_bytes[0], - client_major_version_bytes[1], - client_major_version_bytes[2], - client_major_version_bytes[3], - client_minor_version_bytes[0], - client_minor_version_bytes[1], - client_minor_version_bytes[2], - client_minor_version_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + client_major_version, + client_minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -166,221 +186,359 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the RedirectWindow request pub const REDIRECT_WINDOW_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct RedirectWindowRequest { + pub window: xproto::Window, + pub update: Redirect, +} +impl RedirectWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let update_bytes = u8::from(self.update).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + REDIRECT_WINDOW_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + update_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn redirect_window(conn: &Conn, window: xproto::Window, update: Redirect) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let update_bytes = u8::from(update).serialize(); - let mut request0 = [ - extension_information.major_opcode, - REDIRECT_WINDOW_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - update_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = RedirectWindowRequest { + window, + update, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the RedirectSubwindows request pub const REDIRECT_SUBWINDOWS_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct RedirectSubwindowsRequest { + pub window: xproto::Window, + pub update: Redirect, +} +impl RedirectSubwindowsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let update_bytes = u8::from(self.update).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + REDIRECT_SUBWINDOWS_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + update_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn redirect_subwindows(conn: &Conn, window: xproto::Window, update: Redirect) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let update_bytes = u8::from(update).serialize(); - let mut request0 = [ - extension_information.major_opcode, - REDIRECT_SUBWINDOWS_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - update_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = RedirectSubwindowsRequest { + window, + update, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UnredirectWindow request pub const UNREDIRECT_WINDOW_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UnredirectWindowRequest { + pub window: xproto::Window, + pub update: Redirect, +} +impl UnredirectWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let update_bytes = u8::from(self.update).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + UNREDIRECT_WINDOW_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + update_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn unredirect_window(conn: &Conn, window: xproto::Window, update: Redirect) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let update_bytes = u8::from(update).serialize(); - let mut request0 = [ - extension_information.major_opcode, - UNREDIRECT_WINDOW_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - update_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UnredirectWindowRequest { + window, + update, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UnredirectSubwindows request pub const UNREDIRECT_SUBWINDOWS_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UnredirectSubwindowsRequest { + pub window: xproto::Window, + pub update: Redirect, +} +impl UnredirectSubwindowsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let update_bytes = u8::from(self.update).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + UNREDIRECT_SUBWINDOWS_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + update_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn unredirect_subwindows(conn: &Conn, window: xproto::Window, update: Redirect) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let update_bytes = u8::from(update).serialize(); - let mut request0 = [ - extension_information.major_opcode, - UNREDIRECT_SUBWINDOWS_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - update_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UnredirectSubwindowsRequest { + window, + update, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateRegionFromBorderClip request pub const CREATE_REGION_FROM_BORDER_CLIP_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateRegionFromBorderClipRequest { + pub region: xfixes::Region, + pub window: xproto::Window, +} +impl CreateRegionFromBorderClipRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let region_bytes = self.region.serialize(); + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_REGION_FROM_BORDER_CLIP_REQUEST, + 0, + 0, + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_region_from_border_clip(conn: &Conn, region: xfixes::Region, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let region_bytes = region.serialize(); - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_REGION_FROM_BORDER_CLIP_REQUEST, - 0, - 0, - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateRegionFromBorderClipRequest { + region, + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the NameWindowPixmap request pub const NAME_WINDOW_PIXMAP_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct NameWindowPixmapRequest { + pub window: xproto::Window, + pub pixmap: xproto::Pixmap, +} +impl NameWindowPixmapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let pixmap_bytes = self.pixmap.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + NAME_WINDOW_PIXMAP_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + pixmap_bytes[0], + pixmap_bytes[1], + pixmap_bytes[2], + pixmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn name_window_pixmap(conn: &Conn, window: xproto::Window, pixmap: xproto::Pixmap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let pixmap_bytes = pixmap.serialize(); - let mut request0 = [ - extension_information.major_opcode, - NAME_WINDOW_PIXMAP_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - pixmap_bytes[0], - pixmap_bytes[1], - pixmap_bytes[2], - pixmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = NameWindowPixmapRequest { + window, + pixmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetOverlayWindow request pub const GET_OVERLAY_WINDOW_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetOverlayWindowRequest { + pub window: xproto::Window, +} +impl GetOverlayWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_OVERLAY_WINDOW_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_overlay_window(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_OVERLAY_WINDOW_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetOverlayWindowRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -411,29 +569,47 @@ impl TryFrom<&[u8]> for GetOverlayWindowReply { /// Opcode for the ReleaseOverlayWindow request pub const RELEASE_OVERLAY_WINDOW_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ReleaseOverlayWindowRequest { + pub window: xproto::Window, +} +impl ReleaseOverlayWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + RELEASE_OVERLAY_WINDOW_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn release_overlay_window(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - RELEASE_OVERLAY_WINDOW_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ReleaseOverlayWindowRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Extension trait defining the requests of this extension. diff --git a/src/protocol/damage.rs b/src/protocol/damage.rs index 8afb822e..4c23f682 100644 --- a/src/protocol/damage.rs +++ b/src/protocol/damage.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -177,34 +177,54 @@ impl From for [u8; 32] { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub client_major_version: u32, + pub client_minor_version: u32, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_version_bytes = self.client_major_version.serialize(); + let client_minor_version_bytes = self.client_minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + client_major_version_bytes[0], + client_major_version_bytes[1], + client_major_version_bytes[2], + client_major_version_bytes[3], + client_minor_version_bytes[0], + client_minor_version_bytes[1], + client_minor_version_bytes[2], + client_minor_version_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, client_major_version: u32, client_minor_version: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_version_bytes = client_major_version.serialize(); - let client_minor_version_bytes = client_minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - client_major_version_bytes[0], - client_major_version_bytes[1], - client_major_version_bytes[2], - client_major_version_bytes[3], - client_minor_version_bytes[0], - client_minor_version_bytes[1], - client_minor_version_bytes[2], - client_minor_version_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + client_major_version, + client_minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -237,139 +257,221 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the Create request pub const CREATE_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateRequest { + pub damage: Damage, + pub drawable: xproto::Drawable, + pub level: ReportLevel, +} +impl CreateRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let damage_bytes = self.damage.serialize(); + let drawable_bytes = self.drawable.serialize(); + let level_bytes = u8::from(self.level).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_REQUEST, + 0, + 0, + damage_bytes[0], + damage_bytes[1], + damage_bytes[2], + damage_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + level_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create(conn: &Conn, damage: Damage, drawable: xproto::Drawable, level: ReportLevel) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let damage_bytes = damage.serialize(); - let drawable_bytes = drawable.serialize(); - let level_bytes = u8::from(level).serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_REQUEST, - 0, - 0, - damage_bytes[0], - damage_bytes[1], - damage_bytes[2], - damage_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - level_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateRequest { + damage, + drawable, + level, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Destroy request pub const DESTROY_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyRequest { + pub damage: Damage, +} +impl DestroyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let damage_bytes = self.damage.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_REQUEST, + 0, + 0, + damage_bytes[0], + damage_bytes[1], + damage_bytes[2], + damage_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy(conn: &Conn, damage: Damage) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let damage_bytes = damage.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_REQUEST, - 0, - 0, - damage_bytes[0], - damage_bytes[1], - damage_bytes[2], - damage_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyRequest { + damage, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Subtract request pub const SUBTRACT_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SubtractRequest { + pub damage: Damage, + pub repair: xfixes::Region, + pub parts: xfixes::Region, +} +impl SubtractRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let damage_bytes = self.damage.serialize(); + let repair_bytes = self.repair.serialize(); + let parts_bytes = self.parts.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SUBTRACT_REQUEST, + 0, + 0, + damage_bytes[0], + damage_bytes[1], + damage_bytes[2], + damage_bytes[3], + repair_bytes[0], + repair_bytes[1], + repair_bytes[2], + repair_bytes[3], + parts_bytes[0], + parts_bytes[1], + parts_bytes[2], + parts_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn subtract(conn: &Conn, damage: Damage, repair: A, parts: B) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let repair: xfixes::Region = repair.into(); let parts: xfixes::Region = parts.into(); - let length_so_far = 0; - let damage_bytes = damage.serialize(); - let repair_bytes = repair.serialize(); - let parts_bytes = parts.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SUBTRACT_REQUEST, - 0, - 0, - damage_bytes[0], - damage_bytes[1], - damage_bytes[2], - damage_bytes[3], - repair_bytes[0], - repair_bytes[1], - repair_bytes[2], - repair_bytes[3], - parts_bytes[0], - parts_bytes[1], - parts_bytes[2], - parts_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SubtractRequest { + damage, + repair, + parts, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Add request pub const ADD_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AddRequest { + pub drawable: xproto::Drawable, + pub region: xfixes::Region, +} +impl AddRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let region_bytes = self.region.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + ADD_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn add(conn: &Conn, drawable: xproto::Drawable, region: xfixes::Region) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let region_bytes = region.serialize(); - let mut request0 = [ - extension_information.major_opcode, - ADD_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = AddRequest { + drawable, + region, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Notify event diff --git a/src/protocol/dpms.rs b/src/protocol/dpms.rs index dd2486d1..ca00c800 100644 --- a/src/protocol/dpms.rs +++ b/src/protocol/dpms.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -34,30 +34,50 @@ pub const X11_XML_VERSION: (u32, u32) = (0, 0); /// Opcode for the GetVersion request pub const GET_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetVersionRequest { + pub client_major_version: u16, + pub client_minor_version: u16, +} +impl GetVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_version_bytes = self.client_major_version.serialize(); + let client_minor_version_bytes = self.client_minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_VERSION_REQUEST, + 0, + 0, + client_major_version_bytes[0], + client_major_version_bytes[1], + client_minor_version_bytes[0], + client_minor_version_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_version(conn: &Conn, client_major_version: u16, client_minor_version: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_version_bytes = client_major_version.serialize(); - let client_minor_version_bytes = client_minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_VERSION_REQUEST, - 0, - 0, - client_major_version_bytes[0], - client_major_version_bytes[1], - client_minor_version_bytes[0], - client_minor_version_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetVersionRequest { + client_major_version, + client_minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -89,24 +109,38 @@ impl TryFrom<&[u8]> for GetVersionReply { /// Opcode for the Capable request pub const CAPABLE_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CapableRequest; +impl CapableRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + CAPABLE_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn capable(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - CAPABLE_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CapableRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -137,24 +171,38 @@ impl TryFrom<&[u8]> for CapableReply { /// Opcode for the GetTimeouts request pub const GET_TIMEOUTS_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTimeoutsRequest; +impl GetTimeoutsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + GET_TIMEOUTS_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_timeouts(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - GET_TIMEOUTS_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTimeoutsRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -189,79 +237,129 @@ impl TryFrom<&[u8]> for GetTimeoutsReply { /// Opcode for the SetTimeouts request pub const SET_TIMEOUTS_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetTimeoutsRequest { + pub standby_timeout: u16, + pub suspend_timeout: u16, + pub off_timeout: u16, +} +impl SetTimeoutsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let standby_timeout_bytes = self.standby_timeout.serialize(); + let suspend_timeout_bytes = self.suspend_timeout.serialize(); + let off_timeout_bytes = self.off_timeout.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_TIMEOUTS_REQUEST, + 0, + 0, + standby_timeout_bytes[0], + standby_timeout_bytes[1], + suspend_timeout_bytes[0], + suspend_timeout_bytes[1], + off_timeout_bytes[0], + off_timeout_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_timeouts(conn: &Conn, standby_timeout: u16, suspend_timeout: u16, off_timeout: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let standby_timeout_bytes = standby_timeout.serialize(); - let suspend_timeout_bytes = suspend_timeout.serialize(); - let off_timeout_bytes = off_timeout.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_TIMEOUTS_REQUEST, - 0, - 0, - standby_timeout_bytes[0], - standby_timeout_bytes[1], - suspend_timeout_bytes[0], - suspend_timeout_bytes[1], - off_timeout_bytes[0], - off_timeout_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetTimeoutsRequest { + standby_timeout, + suspend_timeout, + off_timeout, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Enable request pub const ENABLE_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct EnableRequest; +impl EnableRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + ENABLE_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn enable(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - ENABLE_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = EnableRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Disable request pub const DISABLE_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DisableRequest; +impl DisableRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + DISABLE_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn disable(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - DISABLE_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DisableRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -334,51 +432,83 @@ impl TryFrom for DPMSMode { /// Opcode for the ForceLevel request pub const FORCE_LEVEL_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ForceLevelRequest { + pub power_level: DPMSMode, +} +impl ForceLevelRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let power_level_bytes = u16::from(self.power_level).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FORCE_LEVEL_REQUEST, + 0, + 0, + power_level_bytes[0], + power_level_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn force_level(conn: &Conn, power_level: DPMSMode) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let power_level_bytes = u16::from(power_level).serialize(); - let mut request0 = [ - extension_information.major_opcode, - FORCE_LEVEL_REQUEST, - 0, - 0, - power_level_bytes[0], - power_level_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ForceLevelRequest { + power_level, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Info request pub const INFO_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct InfoRequest; +impl InfoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + INFO_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn info(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - INFO_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = InfoRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] diff --git a/src/protocol/dri2.rs b/src/protocol/dri2.rs index c30f601f..801eb96b 100644 --- a/src/protocol/dri2.rs +++ b/src/protocol/dri2.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -370,34 +370,54 @@ impl Serialize for AttachFormat { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub major_version: u32, + pub minor_version: u32, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + major_version_bytes[0], + major_version_bytes[1], + major_version_bytes[2], + major_version_bytes[3], + minor_version_bytes[0], + minor_version_bytes[1], + minor_version_bytes[2], + minor_version_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, major_version: u32, minor_version: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - major_version_bytes[0], - major_version_bytes[1], - major_version_bytes[2], - major_version_bytes[3], - minor_version_bytes[0], - minor_version_bytes[1], - minor_version_bytes[2], - minor_version_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + major_version, + minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -429,34 +449,54 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the Connect request pub const CONNECT_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ConnectRequest { + pub window: xproto::Window, + pub driver_type: DriverType, +} +impl ConnectRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let driver_type_bytes = u32::from(self.driver_type).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CONNECT_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + driver_type_bytes[0], + driver_type_bytes[1], + driver_type_bytes[2], + driver_type_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn connect(conn: &Conn, window: xproto::Window, driver_type: DriverType) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let driver_type_bytes = u32::from(driver_type).serialize(); - let mut request0 = [ - extension_information.major_opcode, - CONNECT_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - driver_type_bytes[0], - driver_type_bytes[1], - driver_type_bytes[2], - driver_type_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ConnectRequest { + window, + driver_type, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -524,34 +564,54 @@ impl ConnectReply { /// Opcode for the Authenticate request pub const AUTHENTICATE_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AuthenticateRequest { + pub window: xproto::Window, + pub magic: u32, +} +impl AuthenticateRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let magic_bytes = self.magic.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + AUTHENTICATE_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + magic_bytes[0], + magic_bytes[1], + magic_bytes[2], + magic_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn authenticate(conn: &Conn, window: xproto::Window, magic: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let magic_bytes = magic.serialize(); - let mut request0 = [ - extension_information.major_opcode, - AUTHENTICATE_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - magic_bytes[0], - magic_bytes[1], - magic_bytes[2], - magic_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = AuthenticateRequest { + window, + magic, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -581,92 +641,150 @@ impl TryFrom<&[u8]> for AuthenticateReply { /// Opcode for the CreateDrawable request pub const CREATE_DRAWABLE_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateDrawableRequest { + pub drawable: xproto::Drawable, +} +impl CreateDrawableRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_DRAWABLE_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_drawable(conn: &Conn, drawable: xproto::Drawable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_DRAWABLE_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateDrawableRequest { + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DestroyDrawable request pub const DESTROY_DRAWABLE_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyDrawableRequest { + pub drawable: xproto::Drawable, +} +impl DestroyDrawableRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_DRAWABLE_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_drawable(conn: &Conn, drawable: xproto::Drawable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_DRAWABLE_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyDrawableRequest { + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetBuffers request pub const GET_BUFFERS_REQUEST: u8 = 5; -pub fn get_buffers<'c, Conn>(conn: &'c Conn, drawable: xproto::Drawable, count: u32, attachments: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct GetBuffersRequest<'input> { + pub drawable: xproto::Drawable, + pub count: u32, + pub attachments: &'input [u32], +} +impl<'input> GetBuffersRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let count_bytes = self.count.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_BUFFERS_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + count_bytes[0], + count_bytes[1], + count_bytes[2], + count_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let attachments_bytes = self.attachments.serialize(); + let length_so_far = length_so_far + attachments_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), attachments_bytes.into(), padding0.into()], vec![])) + } +} +pub fn get_buffers<'c, 'input, Conn>(conn: &'c Conn, drawable: xproto::Drawable, count: u32, attachments: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let count_bytes = count.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_BUFFERS_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - count_bytes[0], - count_bytes[1], - count_bytes[2], - count_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let attachments_bytes = attachments.serialize(); - let length_so_far = length_so_far + attachments_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&attachments_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = GetBuffersRequest { + drawable, + count, + attachments, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -717,44 +835,68 @@ impl GetBuffersReply { /// Opcode for the CopyRegion request pub const COPY_REGION_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CopyRegionRequest { + pub drawable: xproto::Drawable, + pub region: u32, + pub dest: u32, + pub src: u32, +} +impl CopyRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let region_bytes = self.region.serialize(); + let dest_bytes = self.dest.serialize(); + let src_bytes = self.src.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + COPY_REGION_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + dest_bytes[0], + dest_bytes[1], + dest_bytes[2], + dest_bytes[3], + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn copy_region(conn: &Conn, drawable: xproto::Drawable, region: u32, dest: u32, src: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let region_bytes = region.serialize(); - let dest_bytes = dest.serialize(); - let src_bytes = src.serialize(); - let mut request0 = [ - extension_information.major_opcode, - COPY_REGION_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - dest_bytes[0], - dest_bytes[1], - dest_bytes[2], - dest_bytes[3], - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CopyRegionRequest { + drawable, + region, + dest, + src, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -782,38 +924,60 @@ impl TryFrom<&[u8]> for CopyRegionReply { /// Opcode for the GetBuffersWithFormat request pub const GET_BUFFERS_WITH_FORMAT_REQUEST: u8 = 7; -pub fn get_buffers_with_format<'c, Conn>(conn: &'c Conn, drawable: xproto::Drawable, count: u32, attachments: &[AttachFormat]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct GetBuffersWithFormatRequest<'input> { + pub drawable: xproto::Drawable, + pub count: u32, + pub attachments: &'input [AttachFormat], +} +impl<'input> GetBuffersWithFormatRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let count_bytes = self.count.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_BUFFERS_WITH_FORMAT_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + count_bytes[0], + count_bytes[1], + count_bytes[2], + count_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let attachments_bytes = self.attachments.serialize(); + let length_so_far = length_so_far + attachments_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), attachments_bytes.into(), padding0.into()], vec![])) + } +} +pub fn get_buffers_with_format<'c, 'input, Conn>(conn: &'c Conn, drawable: xproto::Drawable, count: u32, attachments: &'input [AttachFormat]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let count_bytes = count.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_BUFFERS_WITH_FORMAT_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - count_bytes[0], - count_bytes[1], - count_bytes[2], - count_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let attachments_bytes = attachments.serialize(); - let length_so_far = length_so_far + attachments_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&attachments_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = GetBuffersWithFormatRequest { + drawable, + count, + attachments, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -864,59 +1028,89 @@ impl GetBuffersWithFormatReply { /// Opcode for the SwapBuffers request pub const SWAP_BUFFERS_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SwapBuffersRequest { + pub drawable: xproto::Drawable, + pub target_msc_hi: u32, + pub target_msc_lo: u32, + pub divisor_hi: u32, + pub divisor_lo: u32, + pub remainder_hi: u32, + pub remainder_lo: u32, +} +impl SwapBuffersRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let target_msc_hi_bytes = self.target_msc_hi.serialize(); + let target_msc_lo_bytes = self.target_msc_lo.serialize(); + let divisor_hi_bytes = self.divisor_hi.serialize(); + let divisor_lo_bytes = self.divisor_lo.serialize(); + let remainder_hi_bytes = self.remainder_hi.serialize(); + let remainder_lo_bytes = self.remainder_lo.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SWAP_BUFFERS_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + target_msc_hi_bytes[0], + target_msc_hi_bytes[1], + target_msc_hi_bytes[2], + target_msc_hi_bytes[3], + target_msc_lo_bytes[0], + target_msc_lo_bytes[1], + target_msc_lo_bytes[2], + target_msc_lo_bytes[3], + divisor_hi_bytes[0], + divisor_hi_bytes[1], + divisor_hi_bytes[2], + divisor_hi_bytes[3], + divisor_lo_bytes[0], + divisor_lo_bytes[1], + divisor_lo_bytes[2], + divisor_lo_bytes[3], + remainder_hi_bytes[0], + remainder_hi_bytes[1], + remainder_hi_bytes[2], + remainder_hi_bytes[3], + remainder_lo_bytes[0], + remainder_lo_bytes[1], + remainder_lo_bytes[2], + remainder_lo_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn swap_buffers(conn: &Conn, drawable: xproto::Drawable, target_msc_hi: u32, target_msc_lo: u32, divisor_hi: u32, divisor_lo: u32, remainder_hi: u32, remainder_lo: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let target_msc_hi_bytes = target_msc_hi.serialize(); - let target_msc_lo_bytes = target_msc_lo.serialize(); - let divisor_hi_bytes = divisor_hi.serialize(); - let divisor_lo_bytes = divisor_lo.serialize(); - let remainder_hi_bytes = remainder_hi.serialize(); - let remainder_lo_bytes = remainder_lo.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SWAP_BUFFERS_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - target_msc_hi_bytes[0], - target_msc_hi_bytes[1], - target_msc_hi_bytes[2], - target_msc_hi_bytes[3], - target_msc_lo_bytes[0], - target_msc_lo_bytes[1], - target_msc_lo_bytes[2], - target_msc_lo_bytes[3], - divisor_hi_bytes[0], - divisor_hi_bytes[1], - divisor_hi_bytes[2], - divisor_hi_bytes[3], - divisor_lo_bytes[0], - divisor_lo_bytes[1], - divisor_lo_bytes[2], - divisor_lo_bytes[3], - remainder_hi_bytes[0], - remainder_hi_bytes[1], - remainder_hi_bytes[2], - remainder_hi_bytes[3], - remainder_lo_bytes[0], - remainder_lo_bytes[1], - remainder_lo_bytes[2], - remainder_lo_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SwapBuffersRequest { + drawable, + target_msc_hi, + target_msc_lo, + divisor_hi, + divisor_lo, + remainder_hi, + remainder_lo, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -948,29 +1142,47 @@ impl TryFrom<&[u8]> for SwapBuffersReply { /// Opcode for the GetMSC request pub const GET_MSC_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMSCRequest { + pub drawable: xproto::Drawable, +} +impl GetMSCRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MSC_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_msc(conn: &Conn, drawable: xproto::Drawable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MSC_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMSCRequest { + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1010,59 +1222,89 @@ impl TryFrom<&[u8]> for GetMSCReply { /// Opcode for the WaitMSC request pub const WAIT_MSC_REQUEST: u8 = 10; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct WaitMSCRequest { + pub drawable: xproto::Drawable, + pub target_msc_hi: u32, + pub target_msc_lo: u32, + pub divisor_hi: u32, + pub divisor_lo: u32, + pub remainder_hi: u32, + pub remainder_lo: u32, +} +impl WaitMSCRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let target_msc_hi_bytes = self.target_msc_hi.serialize(); + let target_msc_lo_bytes = self.target_msc_lo.serialize(); + let divisor_hi_bytes = self.divisor_hi.serialize(); + let divisor_lo_bytes = self.divisor_lo.serialize(); + let remainder_hi_bytes = self.remainder_hi.serialize(); + let remainder_lo_bytes = self.remainder_lo.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + WAIT_MSC_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + target_msc_hi_bytes[0], + target_msc_hi_bytes[1], + target_msc_hi_bytes[2], + target_msc_hi_bytes[3], + target_msc_lo_bytes[0], + target_msc_lo_bytes[1], + target_msc_lo_bytes[2], + target_msc_lo_bytes[3], + divisor_hi_bytes[0], + divisor_hi_bytes[1], + divisor_hi_bytes[2], + divisor_hi_bytes[3], + divisor_lo_bytes[0], + divisor_lo_bytes[1], + divisor_lo_bytes[2], + divisor_lo_bytes[3], + remainder_hi_bytes[0], + remainder_hi_bytes[1], + remainder_hi_bytes[2], + remainder_hi_bytes[3], + remainder_lo_bytes[0], + remainder_lo_bytes[1], + remainder_lo_bytes[2], + remainder_lo_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn wait_msc(conn: &Conn, drawable: xproto::Drawable, target_msc_hi: u32, target_msc_lo: u32, divisor_hi: u32, divisor_lo: u32, remainder_hi: u32, remainder_lo: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let target_msc_hi_bytes = target_msc_hi.serialize(); - let target_msc_lo_bytes = target_msc_lo.serialize(); - let divisor_hi_bytes = divisor_hi.serialize(); - let divisor_lo_bytes = divisor_lo.serialize(); - let remainder_hi_bytes = remainder_hi.serialize(); - let remainder_lo_bytes = remainder_lo.serialize(); - let mut request0 = [ - extension_information.major_opcode, - WAIT_MSC_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - target_msc_hi_bytes[0], - target_msc_hi_bytes[1], - target_msc_hi_bytes[2], - target_msc_hi_bytes[3], - target_msc_lo_bytes[0], - target_msc_lo_bytes[1], - target_msc_lo_bytes[2], - target_msc_lo_bytes[3], - divisor_hi_bytes[0], - divisor_hi_bytes[1], - divisor_hi_bytes[2], - divisor_hi_bytes[3], - divisor_lo_bytes[0], - divisor_lo_bytes[1], - divisor_lo_bytes[2], - divisor_lo_bytes[3], - remainder_hi_bytes[0], - remainder_hi_bytes[1], - remainder_hi_bytes[2], - remainder_hi_bytes[3], - remainder_lo_bytes[0], - remainder_lo_bytes[1], - remainder_lo_bytes[2], - remainder_lo_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = WaitMSCRequest { + drawable, + target_msc_hi, + target_msc_lo, + divisor_hi, + divisor_lo, + remainder_hi, + remainder_lo, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1102,39 +1344,61 @@ impl TryFrom<&[u8]> for WaitMSCReply { /// Opcode for the WaitSBC request pub const WAIT_SBC_REQUEST: u8 = 11; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct WaitSBCRequest { + pub drawable: xproto::Drawable, + pub target_sbc_hi: u32, + pub target_sbc_lo: u32, +} +impl WaitSBCRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let target_sbc_hi_bytes = self.target_sbc_hi.serialize(); + let target_sbc_lo_bytes = self.target_sbc_lo.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + WAIT_SBC_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + target_sbc_hi_bytes[0], + target_sbc_hi_bytes[1], + target_sbc_hi_bytes[2], + target_sbc_hi_bytes[3], + target_sbc_lo_bytes[0], + target_sbc_lo_bytes[1], + target_sbc_lo_bytes[2], + target_sbc_lo_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn wait_sbc(conn: &Conn, drawable: xproto::Drawable, target_sbc_hi: u32, target_sbc_lo: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let target_sbc_hi_bytes = target_sbc_hi.serialize(); - let target_sbc_lo_bytes = target_sbc_lo.serialize(); - let mut request0 = [ - extension_information.major_opcode, - WAIT_SBC_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - target_sbc_hi_bytes[0], - target_sbc_hi_bytes[1], - target_sbc_hi_bytes[2], - target_sbc_hi_bytes[3], - target_sbc_lo_bytes[0], - target_sbc_lo_bytes[1], - target_sbc_lo_bytes[2], - target_sbc_lo_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = WaitSBCRequest { + drawable, + target_sbc_hi, + target_sbc_lo, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1174,66 +1438,106 @@ impl TryFrom<&[u8]> for WaitSBCReply { /// Opcode for the SwapInterval request pub const SWAP_INTERVAL_REQUEST: u8 = 12; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SwapIntervalRequest { + pub drawable: xproto::Drawable, + pub interval: u32, +} +impl SwapIntervalRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let interval_bytes = self.interval.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SWAP_INTERVAL_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + interval_bytes[0], + interval_bytes[1], + interval_bytes[2], + interval_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn swap_interval(conn: &Conn, drawable: xproto::Drawable, interval: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let interval_bytes = interval.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SWAP_INTERVAL_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - interval_bytes[0], - interval_bytes[1], - interval_bytes[2], - interval_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SwapIntervalRequest { + drawable, + interval, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetParam request pub const GET_PARAM_REQUEST: u8 = 13; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetParamRequest { + pub drawable: xproto::Drawable, + pub param: u32, +} +impl GetParamRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let param_bytes = self.param.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PARAM_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + param_bytes[0], + param_bytes[1], + param_bytes[2], + param_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_param(conn: &Conn, drawable: xproto::Drawable, param: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let param_bytes = param.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PARAM_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - param_bytes[0], - param_bytes[1], - param_bytes[2], - param_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetParamRequest { + drawable, + param, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1449,7 +1753,7 @@ pub trait ConnectionExt: RequestConnection { { destroy_drawable(self, drawable) } - fn dri2_get_buffers<'c>(&'c self, drawable: xproto::Drawable, count: u32, attachments: &[u32]) -> Result, ConnectionError> + fn dri2_get_buffers<'c, 'input>(&'c self, drawable: xproto::Drawable, count: u32, attachments: &'input [u32]) -> Result, ConnectionError> { get_buffers(self, drawable, count, attachments) } @@ -1457,7 +1761,7 @@ pub trait ConnectionExt: RequestConnection { { copy_region(self, drawable, region, dest, src) } - fn dri2_get_buffers_with_format<'c>(&'c self, drawable: xproto::Drawable, count: u32, attachments: &[AttachFormat]) -> Result, ConnectionError> + fn dri2_get_buffers_with_format<'c, 'input>(&'c self, drawable: xproto::Drawable, count: u32, attachments: &'input [AttachFormat]) -> Result, ConnectionError> { get_buffers_with_format(self, drawable, count, attachments) } diff --git a/src/protocol/dri3.rs b/src/protocol/dri3.rs index 9614acf3..6fe9c35e 100644 --- a/src/protocol/dri3.rs +++ b/src/protocol/dri3.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -35,34 +35,54 @@ pub const X11_XML_VERSION: (u32, u32) = (1, 2); /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub major_version: u32, + pub minor_version: u32, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + major_version_bytes[0], + major_version_bytes[1], + major_version_bytes[2], + major_version_bytes[3], + minor_version_bytes[0], + minor_version_bytes[1], + minor_version_bytes[2], + minor_version_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, major_version: u32, minor_version: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - major_version_bytes[0], - major_version_bytes[1], - major_version_bytes[2], - major_version_bytes[3], - minor_version_bytes[0], - minor_version_bytes[1], - minor_version_bytes[2], - minor_version_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + major_version, + minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -94,34 +114,54 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the Open request pub const OPEN_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct OpenRequest { + pub drawable: xproto::Drawable, + pub provider: u32, +} +impl OpenRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let provider_bytes = self.provider.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + OPEN_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + provider_bytes[0], + provider_bytes[1], + provider_bytes[2], + provider_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn open(conn: &Conn, drawable: xproto::Drawable, provider: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let provider_bytes = provider.serialize(); - let mut request0 = [ - extension_information.major_opcode, - OPEN_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - provider_bytes[0], - provider_bytes[1], - provider_bytes[2], - provider_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply_with_fds(&[IoSlice::new(&request0)], vec![])?) + let request0 = OpenRequest { + drawable, + provider, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply_with_fds(&slices, fds)?) } #[derive(Debug, PartialEq, Eq)] @@ -155,81 +195,133 @@ impl TryFrom<(&[u8], Vec)> for OpenReply { /// Opcode for the PixmapFromBuffer request pub const PIXMAP_FROM_BUFFER_REQUEST: u8 = 2; +#[derive(Debug, PartialEq, Eq)] +pub struct PixmapFromBufferRequest { + pub pixmap: xproto::Pixmap, + pub drawable: xproto::Drawable, + pub size: u32, + pub width: u16, + pub height: u16, + pub stride: u16, + pub depth: u8, + pub bpp: u8, + pub pixmap_fd: RawFdContainer, +} +impl PixmapFromBufferRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let pixmap_bytes = self.pixmap.serialize(); + let drawable_bytes = self.drawable.serialize(); + let size_bytes = self.size.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let stride_bytes = self.stride.serialize(); + let depth_bytes = self.depth.serialize(); + let bpp_bytes = self.bpp.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PIXMAP_FROM_BUFFER_REQUEST, + 0, + 0, + pixmap_bytes[0], + pixmap_bytes[1], + pixmap_bytes[2], + pixmap_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + size_bytes[0], + size_bytes[1], + size_bytes[2], + size_bytes[3], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + stride_bytes[0], + stride_bytes[1], + depth_bytes[0], + bpp_bytes[0], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![self.pixmap_fd])) + } +} pub fn pixmap_from_buffer(conn: &Conn, pixmap: xproto::Pixmap, drawable: xproto::Drawable, size: u32, width: u16, height: u16, stride: u16, depth: u8, bpp: u8, pixmap_fd: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let pixmap_fd: RawFdContainer = pixmap_fd.into(); - let length_so_far = 0; - let pixmap_bytes = pixmap.serialize(); - let drawable_bytes = drawable.serialize(); - let size_bytes = size.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let stride_bytes = stride.serialize(); - let depth_bytes = depth.serialize(); - let bpp_bytes = bpp.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PIXMAP_FROM_BUFFER_REQUEST, - 0, - 0, - pixmap_bytes[0], - pixmap_bytes[1], - pixmap_bytes[2], - pixmap_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - size_bytes[0], - size_bytes[1], - size_bytes[2], - size_bytes[3], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - stride_bytes[0], - stride_bytes[1], - depth_bytes[0], - bpp_bytes[0], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![pixmap_fd])?) + let request0 = PixmapFromBufferRequest { + pixmap, + drawable, + size, + width, + height, + stride, + depth, + bpp, + pixmap_fd, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the BufferFromPixmap request pub const BUFFER_FROM_PIXMAP_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct BufferFromPixmapRequest { + pub pixmap: xproto::Pixmap, +} +impl BufferFromPixmapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let pixmap_bytes = self.pixmap.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + BUFFER_FROM_PIXMAP_REQUEST, + 0, + 0, + pixmap_bytes[0], + pixmap_bytes[1], + pixmap_bytes[2], + pixmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn buffer_from_pixmap(conn: &Conn, pixmap: xproto::Pixmap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let pixmap_bytes = pixmap.serialize(); - let mut request0 = [ - extension_information.major_opcode, - BUFFER_FROM_PIXMAP_REQUEST, - 0, - 0, - pixmap_bytes[0], - pixmap_bytes[1], - pixmap_bytes[2], - pixmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply_with_fds(&[IoSlice::new(&request0)], vec![])?) + let request0 = BufferFromPixmapRequest { + pixmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply_with_fds(&slices, fds)?) } #[derive(Debug, PartialEq, Eq)] @@ -275,73 +367,117 @@ impl TryFrom<(&[u8], Vec)> for BufferFromPixmapReply { /// Opcode for the FenceFromFD request pub const FENCE_FROM_FD_REQUEST: u8 = 4; +#[derive(Debug, PartialEq, Eq)] +pub struct FenceFromFDRequest { + pub drawable: xproto::Drawable, + pub fence: u32, + pub initially_triggered: bool, + pub fence_fd: RawFdContainer, +} +impl FenceFromFDRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let fence_bytes = self.fence.serialize(); + let initially_triggered_bytes = self.initially_triggered.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FENCE_FROM_FD_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + fence_bytes[0], + fence_bytes[1], + fence_bytes[2], + fence_bytes[3], + initially_triggered_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![self.fence_fd])) + } +} pub fn fence_from_fd(conn: &Conn, drawable: xproto::Drawable, fence: u32, initially_triggered: bool, fence_fd: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let fence_fd: RawFdContainer = fence_fd.into(); - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let fence_bytes = fence.serialize(); - let initially_triggered_bytes = initially_triggered.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FENCE_FROM_FD_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - fence_bytes[0], - fence_bytes[1], - fence_bytes[2], - fence_bytes[3], - initially_triggered_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![fence_fd])?) + let request0 = FenceFromFDRequest { + drawable, + fence, + initially_triggered, + fence_fd, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the FDFromFence request pub const FD_FROM_FENCE_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FDFromFenceRequest { + pub drawable: xproto::Drawable, + pub fence: u32, +} +impl FDFromFenceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let fence_bytes = self.fence.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FD_FROM_FENCE_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + fence_bytes[0], + fence_bytes[1], + fence_bytes[2], + fence_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn fd_from_fence(conn: &Conn, drawable: xproto::Drawable, fence: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let fence_bytes = fence.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FD_FROM_FENCE_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - fence_bytes[0], - fence_bytes[1], - fence_bytes[2], - fence_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply_with_fds(&[IoSlice::new(&request0)], vec![])?) + let request0 = FDFromFenceRequest { + drawable, + fence, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply_with_fds(&slices, fds)?) } #[derive(Debug, PartialEq, Eq)] @@ -375,35 +511,57 @@ impl TryFrom<(&[u8], Vec)> for FDFromFenceReply { /// Opcode for the GetSupportedModifiers request pub const GET_SUPPORTED_MODIFIERS_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetSupportedModifiersRequest { + pub window: u32, + pub depth: u8, + pub bpp: u8, +} +impl GetSupportedModifiersRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let depth_bytes = self.depth.serialize(); + let bpp_bytes = self.bpp.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SUPPORTED_MODIFIERS_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + depth_bytes[0], + bpp_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_supported_modifiers(conn: &Conn, window: u32, depth: u8, bpp: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let depth_bytes = depth.serialize(); - let bpp_bytes = bpp.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SUPPORTED_MODIFIERS_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - depth_bytes[0], - bpp_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetSupportedModifiersRequest { + window, + depth, + bpp, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -466,128 +624,194 @@ impl GetSupportedModifiersReply { /// Opcode for the PixmapFromBuffers request pub const PIXMAP_FROM_BUFFERS_REQUEST: u8 = 7; +#[derive(Debug, PartialEq, Eq)] +pub struct PixmapFromBuffersRequest { + pub pixmap: xproto::Pixmap, + pub window: xproto::Window, + pub width: u16, + pub height: u16, + pub stride0: u32, + pub offset0: u32, + pub stride1: u32, + pub offset1: u32, + pub stride2: u32, + pub offset2: u32, + pub stride3: u32, + pub offset3: u32, + pub depth: u8, + pub bpp: u8, + pub modifier: u64, + pub buffers: Vec, +} +impl PixmapFromBuffersRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let pixmap_bytes = self.pixmap.serialize(); + let window_bytes = self.window.serialize(); + let num_buffers = u8::try_from(self.buffers.len()).expect("`buffers` has too many elements"); + let num_buffers_bytes = num_buffers.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let stride0_bytes = self.stride0.serialize(); + let offset0_bytes = self.offset0.serialize(); + let stride1_bytes = self.stride1.serialize(); + let offset1_bytes = self.offset1.serialize(); + let stride2_bytes = self.stride2.serialize(); + let offset2_bytes = self.offset2.serialize(); + let stride3_bytes = self.stride3.serialize(); + let offset3_bytes = self.offset3.serialize(); + let depth_bytes = self.depth.serialize(); + let bpp_bytes = self.bpp.serialize(); + let modifier_bytes = self.modifier.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PIXMAP_FROM_BUFFERS_REQUEST, + 0, + 0, + pixmap_bytes[0], + pixmap_bytes[1], + pixmap_bytes[2], + pixmap_bytes[3], + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + num_buffers_bytes[0], + 0, + 0, + 0, + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + stride0_bytes[0], + stride0_bytes[1], + stride0_bytes[2], + stride0_bytes[3], + offset0_bytes[0], + offset0_bytes[1], + offset0_bytes[2], + offset0_bytes[3], + stride1_bytes[0], + stride1_bytes[1], + stride1_bytes[2], + stride1_bytes[3], + offset1_bytes[0], + offset1_bytes[1], + offset1_bytes[2], + offset1_bytes[3], + stride2_bytes[0], + stride2_bytes[1], + stride2_bytes[2], + stride2_bytes[3], + offset2_bytes[0], + offset2_bytes[1], + offset2_bytes[2], + offset2_bytes[3], + stride3_bytes[0], + stride3_bytes[1], + stride3_bytes[2], + stride3_bytes[3], + offset3_bytes[0], + offset3_bytes[1], + offset3_bytes[2], + offset3_bytes[3], + depth_bytes[0], + bpp_bytes[0], + 0, + 0, + modifier_bytes[0], + modifier_bytes[1], + modifier_bytes[2], + modifier_bytes[3], + modifier_bytes[4], + modifier_bytes[5], + modifier_bytes[6], + modifier_bytes[7], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], self.buffers)) + } +} pub fn pixmap_from_buffers(conn: &Conn, pixmap: xproto::Pixmap, window: xproto::Window, width: u16, height: u16, stride0: u32, offset0: u32, stride1: u32, offset1: u32, stride2: u32, offset2: u32, stride3: u32, offset3: u32, depth: u8, bpp: u8, modifier: u64, buffers: Vec) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let pixmap_bytes = pixmap.serialize(); - let window_bytes = window.serialize(); - let num_buffers = u8::try_from(buffers.len()).expect("`buffers` has too many elements"); - let num_buffers_bytes = num_buffers.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let stride0_bytes = stride0.serialize(); - let offset0_bytes = offset0.serialize(); - let stride1_bytes = stride1.serialize(); - let offset1_bytes = offset1.serialize(); - let stride2_bytes = stride2.serialize(); - let offset2_bytes = offset2.serialize(); - let stride3_bytes = stride3.serialize(); - let offset3_bytes = offset3.serialize(); - let depth_bytes = depth.serialize(); - let bpp_bytes = bpp.serialize(); - let modifier_bytes = modifier.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PIXMAP_FROM_BUFFERS_REQUEST, - 0, - 0, - pixmap_bytes[0], - pixmap_bytes[1], - pixmap_bytes[2], - pixmap_bytes[3], - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - num_buffers_bytes[0], - 0, - 0, - 0, - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - stride0_bytes[0], - stride0_bytes[1], - stride0_bytes[2], - stride0_bytes[3], - offset0_bytes[0], - offset0_bytes[1], - offset0_bytes[2], - offset0_bytes[3], - stride1_bytes[0], - stride1_bytes[1], - stride1_bytes[2], - stride1_bytes[3], - offset1_bytes[0], - offset1_bytes[1], - offset1_bytes[2], - offset1_bytes[3], - stride2_bytes[0], - stride2_bytes[1], - stride2_bytes[2], - stride2_bytes[3], - offset2_bytes[0], - offset2_bytes[1], - offset2_bytes[2], - offset2_bytes[3], - stride3_bytes[0], - stride3_bytes[1], - stride3_bytes[2], - stride3_bytes[3], - offset3_bytes[0], - offset3_bytes[1], - offset3_bytes[2], - offset3_bytes[3], - depth_bytes[0], - bpp_bytes[0], - 0, - 0, - modifier_bytes[0], - modifier_bytes[1], - modifier_bytes[2], - modifier_bytes[3], - modifier_bytes[4], - modifier_bytes[5], - modifier_bytes[6], - modifier_bytes[7], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], buffers)?) + let request0 = PixmapFromBuffersRequest { + pixmap, + window, + width, + height, + stride0, + offset0, + stride1, + offset1, + stride2, + offset2, + stride3, + offset3, + depth, + bpp, + modifier, + buffers, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the BuffersFromPixmap request pub const BUFFERS_FROM_PIXMAP_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct BuffersFromPixmapRequest { + pub pixmap: xproto::Pixmap, +} +impl BuffersFromPixmapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let pixmap_bytes = self.pixmap.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + BUFFERS_FROM_PIXMAP_REQUEST, + 0, + 0, + pixmap_bytes[0], + pixmap_bytes[1], + pixmap_bytes[2], + pixmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn buffers_from_pixmap(conn: &Conn, pixmap: xproto::Pixmap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let pixmap_bytes = pixmap.serialize(); - let mut request0 = [ - extension_information.major_opcode, - BUFFERS_FROM_PIXMAP_REQUEST, - 0, - 0, - pixmap_bytes[0], - pixmap_bytes[1], - pixmap_bytes[2], - pixmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply_with_fds(&[IoSlice::new(&request0)], vec![])?) + let request0 = BuffersFromPixmapRequest { + pixmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply_with_fds(&slices, fds)?) } #[derive(Debug, PartialEq, Eq)] diff --git a/src/protocol/ge.rs b/src/protocol/ge.rs index 97a59316..d54c3545 100644 --- a/src/protocol/ge.rs +++ b/src/protocol/ge.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -34,30 +34,50 @@ pub const X11_XML_VERSION: (u32, u32) = (1, 0); /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub client_major_version: u16, + pub client_minor_version: u16, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_version_bytes = self.client_major_version.serialize(); + let client_minor_version_bytes = self.client_minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + client_major_version_bytes[0], + client_major_version_bytes[1], + client_minor_version_bytes[0], + client_minor_version_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, client_major_version: u16, client_minor_version: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_version_bytes = client_major_version.serialize(); - let client_minor_version_bytes = client_minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - client_major_version_bytes[0], - client_major_version_bytes[1], - client_minor_version_bytes[0], - client_minor_version_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + client_major_version, + client_minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] diff --git a/src/protocol/glx.rs b/src/protocol/glx.rs index 0e521b8e..0bc228db 100644 --- a/src/protocol/glx.rs +++ b/src/protocol/glx.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -470,185 +470,295 @@ impl TryFrom for PBCDT { /// Opcode for the Render request pub const RENDER_REQUEST: u8 = 1; -pub fn render<'c, Conn>(conn: &'c Conn, context_tag: ContextTag, data: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RenderRequest<'input> { + pub context_tag: ContextTag, + pub data: &'input [u8], +} +impl<'input> RenderRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + RENDER_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.data[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.data[..]).into(), padding0.into()], vec![])) + } +} +pub fn render<'c, 'input, Conn>(conn: &'c Conn, context_tag: ContextTag, data: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - RENDER_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + data.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(data), IoSlice::new(&padding0)], vec![])?) + let request0 = RenderRequest { + context_tag, + data, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the RenderLarge request pub const RENDER_LARGE_REQUEST: u8 = 2; -pub fn render_large<'c, Conn>(conn: &'c Conn, context_tag: ContextTag, request_num: u16, request_total: u16, data: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RenderLargeRequest<'input> { + pub context_tag: ContextTag, + pub request_num: u16, + pub request_total: u16, + pub data: &'input [u8], +} +impl<'input> RenderLargeRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let request_num_bytes = self.request_num.serialize(); + let request_total_bytes = self.request_total.serialize(); + let data_len = u32::try_from(self.data.len()).expect("`data` has too many elements"); + let data_len_bytes = data_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + RENDER_LARGE_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + request_num_bytes[0], + request_num_bytes[1], + request_total_bytes[0], + request_total_bytes[1], + data_len_bytes[0], + data_len_bytes[1], + data_len_bytes[2], + data_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.data[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.data[..]).into(), padding0.into()], vec![])) + } +} +pub fn render_large<'c, 'input, Conn>(conn: &'c Conn, context_tag: ContextTag, request_num: u16, request_total: u16, data: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let request_num_bytes = request_num.serialize(); - let request_total_bytes = request_total.serialize(); - let data_len = u32::try_from(data.len()).expect("`data` has too many elements"); - let data_len_bytes = data_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - RENDER_LARGE_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - request_num_bytes[0], - request_num_bytes[1], - request_total_bytes[0], - request_total_bytes[1], - data_len_bytes[0], - data_len_bytes[1], - data_len_bytes[2], - data_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + data.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(data), IoSlice::new(&padding0)], vec![])?) + let request0 = RenderLargeRequest { + context_tag, + request_num, + request_total, + data, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateContext request pub const CREATE_CONTEXT_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateContextRequest { + pub context: Context, + pub visual: xproto::Visualid, + pub screen: u32, + pub share_list: Context, + pub is_direct: bool, +} +impl CreateContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let visual_bytes = self.visual.serialize(); + let screen_bytes = self.screen.serialize(); + let share_list_bytes = self.share_list.serialize(); + let is_direct_bytes = self.is_direct.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + visual_bytes[0], + visual_bytes[1], + visual_bytes[2], + visual_bytes[3], + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + share_list_bytes[0], + share_list_bytes[1], + share_list_bytes[2], + share_list_bytes[3], + is_direct_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_context(conn: &Conn, context: Context, visual: xproto::Visualid, screen: u32, share_list: Context, is_direct: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let visual_bytes = visual.serialize(); - let screen_bytes = screen.serialize(); - let share_list_bytes = share_list.serialize(); - let is_direct_bytes = is_direct.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - visual_bytes[0], - visual_bytes[1], - visual_bytes[2], - visual_bytes[3], - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - share_list_bytes[0], - share_list_bytes[1], - share_list_bytes[2], - share_list_bytes[3], - is_direct_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateContextRequest { + context, + visual, + screen, + share_list, + is_direct, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DestroyContext request pub const DESTROY_CONTEXT_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyContextRequest { + pub context: Context, +} +impl DestroyContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_context(conn: &Conn, context: Context) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the MakeCurrent request pub const MAKE_CURRENT_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct MakeCurrentRequest { + pub drawable: Drawable, + pub context: Context, + pub old_context_tag: ContextTag, +} +impl MakeCurrentRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let context_bytes = self.context.serialize(); + let old_context_tag_bytes = self.old_context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + MAKE_CURRENT_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + old_context_tag_bytes[0], + old_context_tag_bytes[1], + old_context_tag_bytes[2], + old_context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn make_current(conn: &Conn, drawable: Drawable, context: Context, old_context_tag: ContextTag) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let context_bytes = context.serialize(); - let old_context_tag_bytes = old_context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - MAKE_CURRENT_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - old_context_tag_bytes[0], - old_context_tag_bytes[1], - old_context_tag_bytes[2], - old_context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = MakeCurrentRequest { + drawable, + context, + old_context_tag, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -679,29 +789,47 @@ impl TryFrom<&[u8]> for MakeCurrentReply { /// Opcode for the IsDirect request pub const IS_DIRECT_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct IsDirectRequest { + pub context: Context, +} +impl IsDirectRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + IS_DIRECT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn is_direct(conn: &Conn, context: Context) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - IS_DIRECT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = IsDirectRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -732,34 +860,54 @@ impl TryFrom<&[u8]> for IsDirectReply { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub major_version: u32, + pub minor_version: u32, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + major_version_bytes[0], + major_version_bytes[1], + major_version_bytes[2], + major_version_bytes[3], + minor_version_bytes[0], + minor_version_bytes[1], + minor_version_bytes[2], + minor_version_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, major_version: u32, minor_version: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - major_version_bytes[0], - major_version_bytes[1], - major_version_bytes[2], - major_version_bytes[3], - minor_version_bytes[0], - minor_version_bytes[1], - minor_version_bytes[2], - minor_version_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + major_version, + minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -792,98 +940,158 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the WaitGL request pub const WAIT_GL_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct WaitGLRequest { + pub context_tag: ContextTag, +} +impl WaitGLRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + WAIT_GL_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn wait_gl(conn: &Conn, context_tag: ContextTag) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - WAIT_GL_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = WaitGLRequest { + context_tag, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the WaitX request pub const WAIT_X_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct WaitXRequest { + pub context_tag: ContextTag, +} +impl WaitXRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + WAIT_X_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn wait_x(conn: &Conn, context_tag: ContextTag) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - WAIT_X_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = WaitXRequest { + context_tag, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CopyContext request pub const COPY_CONTEXT_REQUEST: u8 = 10; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CopyContextRequest { + pub src: Context, + pub dest: Context, + pub mask: u32, + pub src_context_tag: ContextTag, +} +impl CopyContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let src_bytes = self.src.serialize(); + let dest_bytes = self.dest.serialize(); + let mask_bytes = self.mask.serialize(); + let src_context_tag_bytes = self.src_context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + COPY_CONTEXT_REQUEST, + 0, + 0, + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + dest_bytes[0], + dest_bytes[1], + dest_bytes[2], + dest_bytes[3], + mask_bytes[0], + mask_bytes[1], + mask_bytes[2], + mask_bytes[3], + src_context_tag_bytes[0], + src_context_tag_bytes[1], + src_context_tag_bytes[2], + src_context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn copy_context(conn: &Conn, src: Context, dest: Context, mask: u32, src_context_tag: ContextTag) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let src_bytes = src.serialize(); - let dest_bytes = dest.serialize(); - let mask_bytes = mask.serialize(); - let src_context_tag_bytes = src_context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - COPY_CONTEXT_REQUEST, - 0, - 0, - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - dest_bytes[0], - dest_bytes[1], - dest_bytes[2], - dest_bytes[3], - mask_bytes[0], - mask_bytes[1], - mask_bytes[2], - mask_bytes[3], - src_context_tag_bytes[0], - src_context_tag_bytes[1], - src_context_tag_bytes[2], - src_context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CopyContextRequest { + src, + dest, + mask, + src_context_tag, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -976,150 +1184,238 @@ impl TryFrom for GC { /// Opcode for the SwapBuffers request pub const SWAP_BUFFERS_REQUEST: u8 = 11; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SwapBuffersRequest { + pub context_tag: ContextTag, + pub drawable: Drawable, +} +impl SwapBuffersRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SWAP_BUFFERS_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn swap_buffers(conn: &Conn, context_tag: ContextTag, drawable: Drawable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SWAP_BUFFERS_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SwapBuffersRequest { + context_tag, + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UseXFont request pub const USE_X_FONT_REQUEST: u8 = 12; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UseXFontRequest { + pub context_tag: ContextTag, + pub font: xproto::Font, + pub first: u32, + pub count: u32, + pub list_base: u32, +} +impl UseXFontRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let font_bytes = self.font.serialize(); + let first_bytes = self.first.serialize(); + let count_bytes = self.count.serialize(); + let list_base_bytes = self.list_base.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + USE_X_FONT_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + font_bytes[0], + font_bytes[1], + font_bytes[2], + font_bytes[3], + first_bytes[0], + first_bytes[1], + first_bytes[2], + first_bytes[3], + count_bytes[0], + count_bytes[1], + count_bytes[2], + count_bytes[3], + list_base_bytes[0], + list_base_bytes[1], + list_base_bytes[2], + list_base_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn use_x_font(conn: &Conn, context_tag: ContextTag, font: xproto::Font, first: u32, count: u32, list_base: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let font_bytes = font.serialize(); - let first_bytes = first.serialize(); - let count_bytes = count.serialize(); - let list_base_bytes = list_base.serialize(); - let mut request0 = [ - extension_information.major_opcode, - USE_X_FONT_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - font_bytes[0], - font_bytes[1], - font_bytes[2], - font_bytes[3], - first_bytes[0], - first_bytes[1], - first_bytes[2], - first_bytes[3], - count_bytes[0], - count_bytes[1], - count_bytes[2], - count_bytes[3], - list_base_bytes[0], - list_base_bytes[1], - list_base_bytes[2], - list_base_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UseXFontRequest { + context_tag, + font, + first, + count, + list_base, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateGLXPixmap request pub const CREATE_GLX_PIXMAP_REQUEST: u8 = 13; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateGLXPixmapRequest { + pub screen: u32, + pub visual: xproto::Visualid, + pub pixmap: xproto::Pixmap, + pub glx_pixmap: Pixmap, +} +impl CreateGLXPixmapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let visual_bytes = self.visual.serialize(); + let pixmap_bytes = self.pixmap.serialize(); + let glx_pixmap_bytes = self.glx_pixmap.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_GLX_PIXMAP_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + visual_bytes[0], + visual_bytes[1], + visual_bytes[2], + visual_bytes[3], + pixmap_bytes[0], + pixmap_bytes[1], + pixmap_bytes[2], + pixmap_bytes[3], + glx_pixmap_bytes[0], + glx_pixmap_bytes[1], + glx_pixmap_bytes[2], + glx_pixmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_glx_pixmap(conn: &Conn, screen: u32, visual: xproto::Visualid, pixmap: xproto::Pixmap, glx_pixmap: Pixmap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let visual_bytes = visual.serialize(); - let pixmap_bytes = pixmap.serialize(); - let glx_pixmap_bytes = glx_pixmap.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_GLX_PIXMAP_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - visual_bytes[0], - visual_bytes[1], - visual_bytes[2], - visual_bytes[3], - pixmap_bytes[0], - pixmap_bytes[1], - pixmap_bytes[2], - pixmap_bytes[3], - glx_pixmap_bytes[0], - glx_pixmap_bytes[1], - glx_pixmap_bytes[2], - glx_pixmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateGLXPixmapRequest { + screen, + visual, + pixmap, + glx_pixmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetVisualConfigs request pub const GET_VISUAL_CONFIGS_REQUEST: u8 = 14; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetVisualConfigsRequest { + pub screen: u32, +} +impl GetVisualConfigsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_VISUAL_CONFIGS_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_visual_configs(conn: &Conn, screen: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_VISUAL_CONFIGS_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetVisualConfigsRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1168,99 +1464,161 @@ impl GetVisualConfigsReply { /// Opcode for the DestroyGLXPixmap request pub const DESTROY_GLX_PIXMAP_REQUEST: u8 = 15; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyGLXPixmapRequest { + pub glx_pixmap: Pixmap, +} +impl DestroyGLXPixmapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let glx_pixmap_bytes = self.glx_pixmap.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_GLX_PIXMAP_REQUEST, + 0, + 0, + glx_pixmap_bytes[0], + glx_pixmap_bytes[1], + glx_pixmap_bytes[2], + glx_pixmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_glx_pixmap(conn: &Conn, glx_pixmap: Pixmap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let glx_pixmap_bytes = glx_pixmap.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_GLX_PIXMAP_REQUEST, - 0, - 0, - glx_pixmap_bytes[0], - glx_pixmap_bytes[1], - glx_pixmap_bytes[2], - glx_pixmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyGLXPixmapRequest { + glx_pixmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the VendorPrivate request pub const VENDOR_PRIVATE_REQUEST: u8 = 16; -pub fn vendor_private<'c, Conn>(conn: &'c Conn, vendor_code: u32, context_tag: ContextTag, data: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct VendorPrivateRequest<'input> { + pub vendor_code: u32, + pub context_tag: ContextTag, + pub data: &'input [u8], +} +impl<'input> VendorPrivateRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let vendor_code_bytes = self.vendor_code.serialize(); + let context_tag_bytes = self.context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + VENDOR_PRIVATE_REQUEST, + 0, + 0, + vendor_code_bytes[0], + vendor_code_bytes[1], + vendor_code_bytes[2], + vendor_code_bytes[3], + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.data[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.data[..]).into(), padding0.into()], vec![])) + } +} +pub fn vendor_private<'c, 'input, Conn>(conn: &'c Conn, vendor_code: u32, context_tag: ContextTag, data: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let vendor_code_bytes = vendor_code.serialize(); - let context_tag_bytes = context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - VENDOR_PRIVATE_REQUEST, - 0, - 0, - vendor_code_bytes[0], - vendor_code_bytes[1], - vendor_code_bytes[2], - vendor_code_bytes[3], - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + data.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(data), IoSlice::new(&padding0)], vec![])?) + let request0 = VendorPrivateRequest { + vendor_code, + context_tag, + data, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the VendorPrivateWithReply request pub const VENDOR_PRIVATE_WITH_REPLY_REQUEST: u8 = 17; -pub fn vendor_private_with_reply<'c, Conn>(conn: &'c Conn, vendor_code: u32, context_tag: ContextTag, data: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct VendorPrivateWithReplyRequest<'input> { + pub vendor_code: u32, + pub context_tag: ContextTag, + pub data: &'input [u8], +} +impl<'input> VendorPrivateWithReplyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let vendor_code_bytes = self.vendor_code.serialize(); + let context_tag_bytes = self.context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + VENDOR_PRIVATE_WITH_REPLY_REQUEST, + 0, + 0, + vendor_code_bytes[0], + vendor_code_bytes[1], + vendor_code_bytes[2], + vendor_code_bytes[3], + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.data[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.data[..]).into(), padding0.into()], vec![])) + } +} +pub fn vendor_private_with_reply<'c, 'input, Conn>(conn: &'c Conn, vendor_code: u32, context_tag: ContextTag, data: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let vendor_code_bytes = vendor_code.serialize(); - let context_tag_bytes = context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - VENDOR_PRIVATE_WITH_REPLY_REQUEST, - 0, - 0, - vendor_code_bytes[0], - vendor_code_bytes[1], - vendor_code_bytes[2], - vendor_code_bytes[3], - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + data.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(data), IoSlice::new(&padding0)], vec![])?) + let request0 = VendorPrivateWithReplyRequest { + vendor_code, + context_tag, + data, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1311,29 +1669,47 @@ impl VendorPrivateWithReplyReply { /// Opcode for the QueryExtensionsString request pub const QUERY_EXTENSIONS_STRING_REQUEST: u8 = 18; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryExtensionsStringRequest { + pub screen: u32, +} +impl QueryExtensionsStringRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_EXTENSIONS_STRING_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_extensions_string(conn: &Conn, screen: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_EXTENSIONS_STRING_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryExtensionsStringRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1365,34 +1741,54 @@ impl TryFrom<&[u8]> for QueryExtensionsStringReply { /// Opcode for the QueryServerString request pub const QUERY_SERVER_STRING_REQUEST: u8 = 19; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryServerStringRequest { + pub screen: u32, + pub name: u32, +} +impl QueryServerStringRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let name_bytes = self.name.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_SERVER_STRING_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + name_bytes[0], + name_bytes[1], + name_bytes[2], + name_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_server_string(conn: &Conn, screen: u32, name: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let name_bytes = name.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_SERVER_STRING_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - name_bytes[0], - name_bytes[1], - name_bytes[2], - name_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryServerStringRequest { + screen, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1441,70 +1837,110 @@ impl QueryServerStringReply { /// Opcode for the ClientInfo request pub const CLIENT_INFO_REQUEST: u8 = 20; -pub fn client_info<'c, Conn>(conn: &'c Conn, major_version: u32, minor_version: u32, string: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ClientInfoRequest<'input> { + pub major_version: u32, + pub minor_version: u32, + pub string: &'input [u8], +} +impl<'input> ClientInfoRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + let str_len = u32::try_from(self.string.len()).expect("`string` has too many elements"); + let str_len_bytes = str_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CLIENT_INFO_REQUEST, + 0, + 0, + major_version_bytes[0], + major_version_bytes[1], + major_version_bytes[2], + major_version_bytes[3], + minor_version_bytes[0], + minor_version_bytes[1], + minor_version_bytes[2], + minor_version_bytes[3], + str_len_bytes[0], + str_len_bytes[1], + str_len_bytes[2], + str_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.string[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.string[..]).into(), padding0.into()], vec![])) + } +} +pub fn client_info<'c, 'input, Conn>(conn: &'c Conn, major_version: u32, minor_version: u32, string: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - let str_len = u32::try_from(string.len()).expect("`string` has too many elements"); - let str_len_bytes = str_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CLIENT_INFO_REQUEST, - 0, - 0, - major_version_bytes[0], - major_version_bytes[1], - major_version_bytes[2], - major_version_bytes[3], - minor_version_bytes[0], - minor_version_bytes[1], - minor_version_bytes[2], - minor_version_bytes[3], - str_len_bytes[0], - str_len_bytes[1], - str_len_bytes[2], - str_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + string.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(string), IoSlice::new(&padding0)], vec![])?) + let request0 = ClientInfoRequest { + major_version, + minor_version, + string, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetFBConfigs request pub const GET_FB_CONFIGS_REQUEST: u8 = 21; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetFBConfigsRequest { + pub screen: u32, +} +impl GetFBConfigsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_FB_CONFIGS_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_fb_configs(conn: &Conn, screen: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_FB_CONFIGS_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetFBConfigsRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1553,161 +1989,251 @@ impl GetFBConfigsReply { /// Opcode for the CreatePixmap request pub const CREATE_PIXMAP_REQUEST: u8 = 22; -pub fn create_pixmap<'c, Conn>(conn: &'c Conn, screen: u32, fbconfig: Fbconfig, pixmap: xproto::Pixmap, glx_pixmap: Pixmap, attribs: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreatePixmapRequest<'input> { + pub screen: u32, + pub fbconfig: Fbconfig, + pub pixmap: xproto::Pixmap, + pub glx_pixmap: Pixmap, + pub attribs: &'input [u32], +} +impl<'input> CreatePixmapRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let fbconfig_bytes = self.fbconfig.serialize(); + let pixmap_bytes = self.pixmap.serialize(); + let glx_pixmap_bytes = self.glx_pixmap.serialize(); + assert_eq!(self.attribs.len() % 2, 0, "`attribs` has an incorrect length, must be a multiple of 2"); + let num_attribs = u32::try_from(self.attribs.len() / 2).expect("`attribs` has too many elements"); + let num_attribs_bytes = num_attribs.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_PIXMAP_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + fbconfig_bytes[0], + fbconfig_bytes[1], + fbconfig_bytes[2], + fbconfig_bytes[3], + pixmap_bytes[0], + pixmap_bytes[1], + pixmap_bytes[2], + pixmap_bytes[3], + glx_pixmap_bytes[0], + glx_pixmap_bytes[1], + glx_pixmap_bytes[2], + glx_pixmap_bytes[3], + num_attribs_bytes[0], + num_attribs_bytes[1], + num_attribs_bytes[2], + num_attribs_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let attribs_bytes = self.attribs.serialize(); + let length_so_far = length_so_far + attribs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), attribs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_pixmap<'c, 'input, Conn>(conn: &'c Conn, screen: u32, fbconfig: Fbconfig, pixmap: xproto::Pixmap, glx_pixmap: Pixmap, attribs: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let fbconfig_bytes = fbconfig.serialize(); - let pixmap_bytes = pixmap.serialize(); - let glx_pixmap_bytes = glx_pixmap.serialize(); - assert_eq!(attribs.len() % 2, 0, "`attribs` has an incorrect length, must be a multiple of 2"); - let num_attribs = u32::try_from(attribs.len() / 2).expect("`attribs` has too many elements"); - let num_attribs_bytes = num_attribs.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_PIXMAP_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - fbconfig_bytes[0], - fbconfig_bytes[1], - fbconfig_bytes[2], - fbconfig_bytes[3], - pixmap_bytes[0], - pixmap_bytes[1], - pixmap_bytes[2], - pixmap_bytes[3], - glx_pixmap_bytes[0], - glx_pixmap_bytes[1], - glx_pixmap_bytes[2], - glx_pixmap_bytes[3], - num_attribs_bytes[0], - num_attribs_bytes[1], - num_attribs_bytes[2], - num_attribs_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let attribs_bytes = attribs.serialize(); - let length_so_far = length_so_far + attribs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&attribs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreatePixmapRequest { + screen, + fbconfig, + pixmap, + glx_pixmap, + attribs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DestroyPixmap request pub const DESTROY_PIXMAP_REQUEST: u8 = 23; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyPixmapRequest { + pub glx_pixmap: Pixmap, +} +impl DestroyPixmapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let glx_pixmap_bytes = self.glx_pixmap.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_PIXMAP_REQUEST, + 0, + 0, + glx_pixmap_bytes[0], + glx_pixmap_bytes[1], + glx_pixmap_bytes[2], + glx_pixmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_pixmap(conn: &Conn, glx_pixmap: Pixmap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let glx_pixmap_bytes = glx_pixmap.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_PIXMAP_REQUEST, - 0, - 0, - glx_pixmap_bytes[0], - glx_pixmap_bytes[1], - glx_pixmap_bytes[2], - glx_pixmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyPixmapRequest { + glx_pixmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateNewContext request pub const CREATE_NEW_CONTEXT_REQUEST: u8 = 24; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateNewContextRequest { + pub context: Context, + pub fbconfig: Fbconfig, + pub screen: u32, + pub render_type: u32, + pub share_list: Context, + pub is_direct: bool, +} +impl CreateNewContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let fbconfig_bytes = self.fbconfig.serialize(); + let screen_bytes = self.screen.serialize(); + let render_type_bytes = self.render_type.serialize(); + let share_list_bytes = self.share_list.serialize(); + let is_direct_bytes = self.is_direct.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_NEW_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + fbconfig_bytes[0], + fbconfig_bytes[1], + fbconfig_bytes[2], + fbconfig_bytes[3], + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + render_type_bytes[0], + render_type_bytes[1], + render_type_bytes[2], + render_type_bytes[3], + share_list_bytes[0], + share_list_bytes[1], + share_list_bytes[2], + share_list_bytes[3], + is_direct_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_new_context(conn: &Conn, context: Context, fbconfig: Fbconfig, screen: u32, render_type: u32, share_list: Context, is_direct: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let fbconfig_bytes = fbconfig.serialize(); - let screen_bytes = screen.serialize(); - let render_type_bytes = render_type.serialize(); - let share_list_bytes = share_list.serialize(); - let is_direct_bytes = is_direct.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_NEW_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - fbconfig_bytes[0], - fbconfig_bytes[1], - fbconfig_bytes[2], - fbconfig_bytes[3], - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - render_type_bytes[0], - render_type_bytes[1], - render_type_bytes[2], - render_type_bytes[3], - share_list_bytes[0], - share_list_bytes[1], - share_list_bytes[2], - share_list_bytes[3], - is_direct_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateNewContextRequest { + context, + fbconfig, + screen, + render_type, + share_list, + is_direct, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the QueryContext request pub const QUERY_CONTEXT_REQUEST: u8 = 25; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryContextRequest { + pub context: Context, +} +impl QueryContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_context(conn: &Conn, context: Context) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1755,44 +2281,68 @@ impl QueryContextReply { /// Opcode for the MakeContextCurrent request pub const MAKE_CONTEXT_CURRENT_REQUEST: u8 = 26; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct MakeContextCurrentRequest { + pub old_context_tag: ContextTag, + pub drawable: Drawable, + pub read_drawable: Drawable, + pub context: Context, +} +impl MakeContextCurrentRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let old_context_tag_bytes = self.old_context_tag.serialize(); + let drawable_bytes = self.drawable.serialize(); + let read_drawable_bytes = self.read_drawable.serialize(); + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + MAKE_CONTEXT_CURRENT_REQUEST, + 0, + 0, + old_context_tag_bytes[0], + old_context_tag_bytes[1], + old_context_tag_bytes[2], + old_context_tag_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + read_drawable_bytes[0], + read_drawable_bytes[1], + read_drawable_bytes[2], + read_drawable_bytes[3], + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn make_context_current(conn: &Conn, old_context_tag: ContextTag, drawable: Drawable, read_drawable: Drawable, context: Context) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let old_context_tag_bytes = old_context_tag.serialize(); - let drawable_bytes = drawable.serialize(); - let read_drawable_bytes = read_drawable.serialize(); - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - MAKE_CONTEXT_CURRENT_REQUEST, - 0, - 0, - old_context_tag_bytes[0], - old_context_tag_bytes[1], - old_context_tag_bytes[2], - old_context_tag_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - read_drawable_bytes[0], - read_drawable_bytes[1], - read_drawable_bytes[2], - read_drawable_bytes[3], - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = MakeContextCurrentRequest { + old_context_tag, + drawable, + read_drawable, + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1823,104 +2373,164 @@ impl TryFrom<&[u8]> for MakeContextCurrentReply { /// Opcode for the CreatePbuffer request pub const CREATE_PBUFFER_REQUEST: u8 = 27; -pub fn create_pbuffer<'c, Conn>(conn: &'c Conn, screen: u32, fbconfig: Fbconfig, pbuffer: Pbuffer, attribs: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreatePbufferRequest<'input> { + pub screen: u32, + pub fbconfig: Fbconfig, + pub pbuffer: Pbuffer, + pub attribs: &'input [u32], +} +impl<'input> CreatePbufferRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let fbconfig_bytes = self.fbconfig.serialize(); + let pbuffer_bytes = self.pbuffer.serialize(); + assert_eq!(self.attribs.len() % 2, 0, "`attribs` has an incorrect length, must be a multiple of 2"); + let num_attribs = u32::try_from(self.attribs.len() / 2).expect("`attribs` has too many elements"); + let num_attribs_bytes = num_attribs.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_PBUFFER_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + fbconfig_bytes[0], + fbconfig_bytes[1], + fbconfig_bytes[2], + fbconfig_bytes[3], + pbuffer_bytes[0], + pbuffer_bytes[1], + pbuffer_bytes[2], + pbuffer_bytes[3], + num_attribs_bytes[0], + num_attribs_bytes[1], + num_attribs_bytes[2], + num_attribs_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let attribs_bytes = self.attribs.serialize(); + let length_so_far = length_so_far + attribs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), attribs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_pbuffer<'c, 'input, Conn>(conn: &'c Conn, screen: u32, fbconfig: Fbconfig, pbuffer: Pbuffer, attribs: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let fbconfig_bytes = fbconfig.serialize(); - let pbuffer_bytes = pbuffer.serialize(); - assert_eq!(attribs.len() % 2, 0, "`attribs` has an incorrect length, must be a multiple of 2"); - let num_attribs = u32::try_from(attribs.len() / 2).expect("`attribs` has too many elements"); - let num_attribs_bytes = num_attribs.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_PBUFFER_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - fbconfig_bytes[0], - fbconfig_bytes[1], - fbconfig_bytes[2], - fbconfig_bytes[3], - pbuffer_bytes[0], - pbuffer_bytes[1], - pbuffer_bytes[2], - pbuffer_bytes[3], - num_attribs_bytes[0], - num_attribs_bytes[1], - num_attribs_bytes[2], - num_attribs_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let attribs_bytes = attribs.serialize(); - let length_so_far = length_so_far + attribs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&attribs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreatePbufferRequest { + screen, + fbconfig, + pbuffer, + attribs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DestroyPbuffer request pub const DESTROY_PBUFFER_REQUEST: u8 = 28; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyPbufferRequest { + pub pbuffer: Pbuffer, +} +impl DestroyPbufferRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let pbuffer_bytes = self.pbuffer.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_PBUFFER_REQUEST, + 0, + 0, + pbuffer_bytes[0], + pbuffer_bytes[1], + pbuffer_bytes[2], + pbuffer_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_pbuffer(conn: &Conn, pbuffer: Pbuffer) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let pbuffer_bytes = pbuffer.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_PBUFFER_REQUEST, - 0, - 0, - pbuffer_bytes[0], - pbuffer_bytes[1], - pbuffer_bytes[2], - pbuffer_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyPbufferRequest { + pbuffer, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetDrawableAttributes request pub const GET_DRAWABLE_ATTRIBUTES_REQUEST: u8 = 29; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDrawableAttributesRequest { + pub drawable: Drawable, +} +impl GetDrawableAttributesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DRAWABLE_ATTRIBUTES_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_drawable_attributes(conn: &Conn, drawable: Drawable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DRAWABLE_ATTRIBUTES_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDrawableAttributesRequest { + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1968,425 +2578,651 @@ impl GetDrawableAttributesReply { /// Opcode for the ChangeDrawableAttributes request pub const CHANGE_DRAWABLE_ATTRIBUTES_REQUEST: u8 = 30; -pub fn change_drawable_attributes<'c, Conn>(conn: &'c Conn, drawable: Drawable, attribs: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeDrawableAttributesRequest<'input> { + pub drawable: Drawable, + pub attribs: &'input [u32], +} +impl<'input> ChangeDrawableAttributesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + assert_eq!(self.attribs.len() % 2, 0, "`attribs` has an incorrect length, must be a multiple of 2"); + let num_attribs = u32::try_from(self.attribs.len() / 2).expect("`attribs` has too many elements"); + let num_attribs_bytes = num_attribs.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_DRAWABLE_ATTRIBUTES_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + num_attribs_bytes[0], + num_attribs_bytes[1], + num_attribs_bytes[2], + num_attribs_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let attribs_bytes = self.attribs.serialize(); + let length_so_far = length_so_far + attribs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), attribs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn change_drawable_attributes<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, attribs: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - assert_eq!(attribs.len() % 2, 0, "`attribs` has an incorrect length, must be a multiple of 2"); - let num_attribs = u32::try_from(attribs.len() / 2).expect("`attribs` has too many elements"); - let num_attribs_bytes = num_attribs.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_DRAWABLE_ATTRIBUTES_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - num_attribs_bytes[0], - num_attribs_bytes[1], - num_attribs_bytes[2], - num_attribs_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let attribs_bytes = attribs.serialize(); - let length_so_far = length_so_far + attribs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&attribs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeDrawableAttributesRequest { + drawable, + attribs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateWindow request pub const CREATE_WINDOW_REQUEST: u8 = 31; -pub fn create_window<'c, Conn>(conn: &'c Conn, screen: u32, fbconfig: Fbconfig, window: xproto::Window, glx_window: Window, attribs: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateWindowRequest<'input> { + pub screen: u32, + pub fbconfig: Fbconfig, + pub window: xproto::Window, + pub glx_window: Window, + pub attribs: &'input [u32], +} +impl<'input> CreateWindowRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let fbconfig_bytes = self.fbconfig.serialize(); + let window_bytes = self.window.serialize(); + let glx_window_bytes = self.glx_window.serialize(); + assert_eq!(self.attribs.len() % 2, 0, "`attribs` has an incorrect length, must be a multiple of 2"); + let num_attribs = u32::try_from(self.attribs.len() / 2).expect("`attribs` has too many elements"); + let num_attribs_bytes = num_attribs.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_WINDOW_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + fbconfig_bytes[0], + fbconfig_bytes[1], + fbconfig_bytes[2], + fbconfig_bytes[3], + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + glx_window_bytes[0], + glx_window_bytes[1], + glx_window_bytes[2], + glx_window_bytes[3], + num_attribs_bytes[0], + num_attribs_bytes[1], + num_attribs_bytes[2], + num_attribs_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let attribs_bytes = self.attribs.serialize(); + let length_so_far = length_so_far + attribs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), attribs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_window<'c, 'input, Conn>(conn: &'c Conn, screen: u32, fbconfig: Fbconfig, window: xproto::Window, glx_window: Window, attribs: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let fbconfig_bytes = fbconfig.serialize(); - let window_bytes = window.serialize(); - let glx_window_bytes = glx_window.serialize(); - assert_eq!(attribs.len() % 2, 0, "`attribs` has an incorrect length, must be a multiple of 2"); - let num_attribs = u32::try_from(attribs.len() / 2).expect("`attribs` has too many elements"); - let num_attribs_bytes = num_attribs.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_WINDOW_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - fbconfig_bytes[0], - fbconfig_bytes[1], - fbconfig_bytes[2], - fbconfig_bytes[3], - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - glx_window_bytes[0], - glx_window_bytes[1], - glx_window_bytes[2], - glx_window_bytes[3], - num_attribs_bytes[0], - num_attribs_bytes[1], - num_attribs_bytes[2], - num_attribs_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let attribs_bytes = attribs.serialize(); - let length_so_far = length_so_far + attribs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&attribs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateWindowRequest { + screen, + fbconfig, + window, + glx_window, + attribs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeleteWindow request pub const DELETE_WINDOW_REQUEST: u8 = 32; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DeleteWindowRequest { + pub glxwindow: Window, +} +impl DeleteWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let glxwindow_bytes = self.glxwindow.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_WINDOW_REQUEST, + 0, + 0, + glxwindow_bytes[0], + glxwindow_bytes[1], + glxwindow_bytes[2], + glxwindow_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn delete_window(conn: &Conn, glxwindow: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let glxwindow_bytes = glxwindow.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_WINDOW_REQUEST, - 0, - 0, - glxwindow_bytes[0], - glxwindow_bytes[1], - glxwindow_bytes[2], - glxwindow_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DeleteWindowRequest { + glxwindow, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetClientInfoARB request pub const SET_CLIENT_INFO_ARB_REQUEST: u8 = 33; -pub fn set_client_info_arb<'c, Conn>(conn: &'c Conn, major_version: u32, minor_version: u32, gl_versions: &[u32], gl_extension_string: &[u8], glx_extension_string: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetClientInfoARBRequest<'input> { + pub major_version: u32, + pub minor_version: u32, + pub gl_versions: &'input [u32], + pub gl_extension_string: &'input [u8], + pub glx_extension_string: &'input [u8], +} +impl<'input> SetClientInfoARBRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + assert_eq!(self.gl_versions.len() % 2, 0, "`gl_versions` has an incorrect length, must be a multiple of 2"); + let num_versions = u32::try_from(self.gl_versions.len() / 2).expect("`gl_versions` has too many elements"); + let num_versions_bytes = num_versions.serialize(); + let gl_str_len = u32::try_from(self.gl_extension_string.len()).expect("`gl_extension_string` has too many elements"); + let gl_str_len_bytes = gl_str_len.serialize(); + let glx_str_len = u32::try_from(self.glx_extension_string.len()).expect("`glx_extension_string` has too many elements"); + let glx_str_len_bytes = glx_str_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_CLIENT_INFO_ARB_REQUEST, + 0, + 0, + major_version_bytes[0], + major_version_bytes[1], + major_version_bytes[2], + major_version_bytes[3], + minor_version_bytes[0], + minor_version_bytes[1], + minor_version_bytes[2], + minor_version_bytes[3], + num_versions_bytes[0], + num_versions_bytes[1], + num_versions_bytes[2], + num_versions_bytes[3], + gl_str_len_bytes[0], + gl_str_len_bytes[1], + gl_str_len_bytes[2], + gl_str_len_bytes[3], + glx_str_len_bytes[0], + glx_str_len_bytes[1], + glx_str_len_bytes[2], + glx_str_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let gl_versions_bytes = self.gl_versions.serialize(); + let length_so_far = length_so_far + gl_versions_bytes.len(); + let length_so_far = length_so_far + (&self.gl_extension_string[..]).len(); + let length_so_far = length_so_far + (&self.glx_extension_string[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), gl_versions_bytes.into(), (&self.gl_extension_string[..]).into(), (&self.glx_extension_string[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_client_info_arb<'c, 'input, Conn>(conn: &'c Conn, major_version: u32, minor_version: u32, gl_versions: &'input [u32], gl_extension_string: &'input [u8], glx_extension_string: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - assert_eq!(gl_versions.len() % 2, 0, "`gl_versions` has an incorrect length, must be a multiple of 2"); - let num_versions = u32::try_from(gl_versions.len() / 2).expect("`gl_versions` has too many elements"); - let num_versions_bytes = num_versions.serialize(); - let gl_str_len = u32::try_from(gl_extension_string.len()).expect("`gl_extension_string` has too many elements"); - let gl_str_len_bytes = gl_str_len.serialize(); - let glx_str_len = u32::try_from(glx_extension_string.len()).expect("`glx_extension_string` has too many elements"); - let glx_str_len_bytes = glx_str_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_CLIENT_INFO_ARB_REQUEST, - 0, - 0, - major_version_bytes[0], - major_version_bytes[1], - major_version_bytes[2], - major_version_bytes[3], - minor_version_bytes[0], - minor_version_bytes[1], - minor_version_bytes[2], - minor_version_bytes[3], - num_versions_bytes[0], - num_versions_bytes[1], - num_versions_bytes[2], - num_versions_bytes[3], - gl_str_len_bytes[0], - gl_str_len_bytes[1], - gl_str_len_bytes[2], - gl_str_len_bytes[3], - glx_str_len_bytes[0], - glx_str_len_bytes[1], - glx_str_len_bytes[2], - glx_str_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let gl_versions_bytes = gl_versions.serialize(); - let length_so_far = length_so_far + gl_versions_bytes.len(); - let length_so_far = length_so_far + gl_extension_string.len(); - let length_so_far = length_so_far + glx_extension_string.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&gl_versions_bytes), IoSlice::new(gl_extension_string), IoSlice::new(glx_extension_string), IoSlice::new(&padding0)], vec![])?) + let request0 = SetClientInfoARBRequest { + major_version, + minor_version, + gl_versions, + gl_extension_string, + glx_extension_string, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateContextAttribsARB request pub const CREATE_CONTEXT_ATTRIBS_ARB_REQUEST: u8 = 34; -pub fn create_context_attribs_arb<'c, Conn>(conn: &'c Conn, context: Context, fbconfig: Fbconfig, screen: u32, share_list: Context, is_direct: bool, attribs: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateContextAttribsARBRequest<'input> { + pub context: Context, + pub fbconfig: Fbconfig, + pub screen: u32, + pub share_list: Context, + pub is_direct: bool, + pub attribs: &'input [u32], +} +impl<'input> CreateContextAttribsARBRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let fbconfig_bytes = self.fbconfig.serialize(); + let screen_bytes = self.screen.serialize(); + let share_list_bytes = self.share_list.serialize(); + let is_direct_bytes = self.is_direct.serialize(); + assert_eq!(self.attribs.len() % 2, 0, "`attribs` has an incorrect length, must be a multiple of 2"); + let num_attribs = u32::try_from(self.attribs.len() / 2).expect("`attribs` has too many elements"); + let num_attribs_bytes = num_attribs.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_CONTEXT_ATTRIBS_ARB_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + fbconfig_bytes[0], + fbconfig_bytes[1], + fbconfig_bytes[2], + fbconfig_bytes[3], + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + share_list_bytes[0], + share_list_bytes[1], + share_list_bytes[2], + share_list_bytes[3], + is_direct_bytes[0], + 0, + 0, + 0, + num_attribs_bytes[0], + num_attribs_bytes[1], + num_attribs_bytes[2], + num_attribs_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let attribs_bytes = self.attribs.serialize(); + let length_so_far = length_so_far + attribs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), attribs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_context_attribs_arb<'c, 'input, Conn>(conn: &'c Conn, context: Context, fbconfig: Fbconfig, screen: u32, share_list: Context, is_direct: bool, attribs: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let fbconfig_bytes = fbconfig.serialize(); - let screen_bytes = screen.serialize(); - let share_list_bytes = share_list.serialize(); - let is_direct_bytes = is_direct.serialize(); - assert_eq!(attribs.len() % 2, 0, "`attribs` has an incorrect length, must be a multiple of 2"); - let num_attribs = u32::try_from(attribs.len() / 2).expect("`attribs` has too many elements"); - let num_attribs_bytes = num_attribs.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_CONTEXT_ATTRIBS_ARB_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - fbconfig_bytes[0], - fbconfig_bytes[1], - fbconfig_bytes[2], - fbconfig_bytes[3], - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - share_list_bytes[0], - share_list_bytes[1], - share_list_bytes[2], - share_list_bytes[3], - is_direct_bytes[0], - 0, - 0, - 0, - num_attribs_bytes[0], - num_attribs_bytes[1], - num_attribs_bytes[2], - num_attribs_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let attribs_bytes = attribs.serialize(); - let length_so_far = length_so_far + attribs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&attribs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateContextAttribsARBRequest { + context, + fbconfig, + screen, + share_list, + is_direct, + attribs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetClientInfo2ARB request pub const SET_CLIENT_INFO2_ARB_REQUEST: u8 = 35; -pub fn set_client_info2_arb<'c, Conn>(conn: &'c Conn, major_version: u32, minor_version: u32, gl_versions: &[u32], gl_extension_string: &[u8], glx_extension_string: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetClientInfo2ARBRequest<'input> { + pub major_version: u32, + pub minor_version: u32, + pub gl_versions: &'input [u32], + pub gl_extension_string: &'input [u8], + pub glx_extension_string: &'input [u8], +} +impl<'input> SetClientInfo2ARBRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + assert_eq!(self.gl_versions.len() % 3, 0, "`gl_versions` has an incorrect length, must be a multiple of 3"); + let num_versions = u32::try_from(self.gl_versions.len() / 3).expect("`gl_versions` has too many elements"); + let num_versions_bytes = num_versions.serialize(); + let gl_str_len = u32::try_from(self.gl_extension_string.len()).expect("`gl_extension_string` has too many elements"); + let gl_str_len_bytes = gl_str_len.serialize(); + let glx_str_len = u32::try_from(self.glx_extension_string.len()).expect("`glx_extension_string` has too many elements"); + let glx_str_len_bytes = glx_str_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_CLIENT_INFO2_ARB_REQUEST, + 0, + 0, + major_version_bytes[0], + major_version_bytes[1], + major_version_bytes[2], + major_version_bytes[3], + minor_version_bytes[0], + minor_version_bytes[1], + minor_version_bytes[2], + minor_version_bytes[3], + num_versions_bytes[0], + num_versions_bytes[1], + num_versions_bytes[2], + num_versions_bytes[3], + gl_str_len_bytes[0], + gl_str_len_bytes[1], + gl_str_len_bytes[2], + gl_str_len_bytes[3], + glx_str_len_bytes[0], + glx_str_len_bytes[1], + glx_str_len_bytes[2], + glx_str_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let gl_versions_bytes = self.gl_versions.serialize(); + let length_so_far = length_so_far + gl_versions_bytes.len(); + let length_so_far = length_so_far + (&self.gl_extension_string[..]).len(); + let length_so_far = length_so_far + (&self.glx_extension_string[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), gl_versions_bytes.into(), (&self.gl_extension_string[..]).into(), (&self.glx_extension_string[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_client_info2_arb<'c, 'input, Conn>(conn: &'c Conn, major_version: u32, minor_version: u32, gl_versions: &'input [u32], gl_extension_string: &'input [u8], glx_extension_string: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - assert_eq!(gl_versions.len() % 3, 0, "`gl_versions` has an incorrect length, must be a multiple of 3"); - let num_versions = u32::try_from(gl_versions.len() / 3).expect("`gl_versions` has too many elements"); - let num_versions_bytes = num_versions.serialize(); - let gl_str_len = u32::try_from(gl_extension_string.len()).expect("`gl_extension_string` has too many elements"); - let gl_str_len_bytes = gl_str_len.serialize(); - let glx_str_len = u32::try_from(glx_extension_string.len()).expect("`glx_extension_string` has too many elements"); - let glx_str_len_bytes = glx_str_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_CLIENT_INFO2_ARB_REQUEST, - 0, - 0, - major_version_bytes[0], - major_version_bytes[1], - major_version_bytes[2], - major_version_bytes[3], - minor_version_bytes[0], - minor_version_bytes[1], - minor_version_bytes[2], - minor_version_bytes[3], - num_versions_bytes[0], - num_versions_bytes[1], - num_versions_bytes[2], - num_versions_bytes[3], - gl_str_len_bytes[0], - gl_str_len_bytes[1], - gl_str_len_bytes[2], - gl_str_len_bytes[3], - glx_str_len_bytes[0], - glx_str_len_bytes[1], - glx_str_len_bytes[2], - glx_str_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let gl_versions_bytes = gl_versions.serialize(); - let length_so_far = length_so_far + gl_versions_bytes.len(); - let length_so_far = length_so_far + gl_extension_string.len(); - let length_so_far = length_so_far + glx_extension_string.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&gl_versions_bytes), IoSlice::new(gl_extension_string), IoSlice::new(glx_extension_string), IoSlice::new(&padding0)], vec![])?) + let request0 = SetClientInfo2ARBRequest { + major_version, + minor_version, + gl_versions, + gl_extension_string, + glx_extension_string, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the NewList request pub const NEW_LIST_REQUEST: u8 = 101; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct NewListRequest { + pub context_tag: ContextTag, + pub list: u32, + pub mode: u32, +} +impl NewListRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let list_bytes = self.list.serialize(); + let mode_bytes = self.mode.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + NEW_LIST_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + list_bytes[0], + list_bytes[1], + list_bytes[2], + list_bytes[3], + mode_bytes[0], + mode_bytes[1], + mode_bytes[2], + mode_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn new_list(conn: &Conn, context_tag: ContextTag, list: u32, mode: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let list_bytes = list.serialize(); - let mode_bytes = mode.serialize(); - let mut request0 = [ - extension_information.major_opcode, - NEW_LIST_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - list_bytes[0], - list_bytes[1], - list_bytes[2], - list_bytes[3], - mode_bytes[0], - mode_bytes[1], - mode_bytes[2], - mode_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = NewListRequest { + context_tag, + list, + mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the EndList request pub const END_LIST_REQUEST: u8 = 102; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct EndListRequest { + pub context_tag: ContextTag, +} +impl EndListRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + END_LIST_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn end_list(conn: &Conn, context_tag: ContextTag) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - END_LIST_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = EndListRequest { + context_tag, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeleteLists request pub const DELETE_LISTS_REQUEST: u8 = 103; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DeleteListsRequest { + pub context_tag: ContextTag, + pub list: u32, + pub range: i32, +} +impl DeleteListsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let list_bytes = self.list.serialize(); + let range_bytes = self.range.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_LISTS_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + list_bytes[0], + list_bytes[1], + list_bytes[2], + list_bytes[3], + range_bytes[0], + range_bytes[1], + range_bytes[2], + range_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn delete_lists(conn: &Conn, context_tag: ContextTag, list: u32, range: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let list_bytes = list.serialize(); - let range_bytes = range.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_LISTS_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - list_bytes[0], - list_bytes[1], - list_bytes[2], - list_bytes[3], - range_bytes[0], - range_bytes[1], - range_bytes[2], - range_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DeleteListsRequest { + context_tag, + list, + range, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GenLists request pub const GEN_LISTS_REQUEST: u8 = 104; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GenListsRequest { + pub context_tag: ContextTag, + pub range: i32, +} +impl GenListsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let range_bytes = self.range.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GEN_LISTS_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + range_bytes[0], + range_bytes[1], + range_bytes[2], + range_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn gen_lists(conn: &Conn, context_tag: ContextTag, range: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let range_bytes = range.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GEN_LISTS_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - range_bytes[0], - range_bytes[1], - range_bytes[2], - range_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GenListsRequest { + context_tag, + range, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -2416,103 +3252,165 @@ impl TryFrom<&[u8]> for GenListsReply { /// Opcode for the FeedbackBuffer request pub const FEEDBACK_BUFFER_REQUEST: u8 = 105; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FeedbackBufferRequest { + pub context_tag: ContextTag, + pub size: i32, + pub type_: i32, +} +impl FeedbackBufferRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let size_bytes = self.size.serialize(); + let type_bytes = self.type_.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FEEDBACK_BUFFER_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + size_bytes[0], + size_bytes[1], + size_bytes[2], + size_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn feedback_buffer(conn: &Conn, context_tag: ContextTag, size: i32, type_: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let size_bytes = size.serialize(); - let type_bytes = type_.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FEEDBACK_BUFFER_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - size_bytes[0], - size_bytes[1], - size_bytes[2], - size_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FeedbackBufferRequest { + context_tag, + size, + type_, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SelectBuffer request pub const SELECT_BUFFER_REQUEST: u8 = 106; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectBufferRequest { + pub context_tag: ContextTag, + pub size: i32, +} +impl SelectBufferRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let size_bytes = self.size.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_BUFFER_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + size_bytes[0], + size_bytes[1], + size_bytes[2], + size_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn select_buffer(conn: &Conn, context_tag: ContextTag, size: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let size_bytes = size.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_BUFFER_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - size_bytes[0], - size_bytes[1], - size_bytes[2], - size_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SelectBufferRequest { + context_tag, + size, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the RenderMode request pub const RENDER_MODE_REQUEST: u8 = 107; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct RenderModeRequest { + pub context_tag: ContextTag, + pub mode: u32, +} +impl RenderModeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let mode_bytes = self.mode.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + RENDER_MODE_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + mode_bytes[0], + mode_bytes[1], + mode_bytes[2], + mode_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn render_mode(conn: &Conn, context_tag: ContextTag, mode: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let mode_bytes = mode.serialize(); - let mut request0 = [ - extension_information.major_opcode, - RENDER_MODE_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - mode_bytes[0], - mode_bytes[1], - mode_bytes[2], - mode_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = RenderModeRequest { + context_tag, + mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2613,29 +3511,47 @@ impl TryFrom for RM { /// Opcode for the Finish request pub const FINISH_REQUEST: u8 = 108; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FinishRequest { + pub context_tag: ContextTag, +} +impl FinishRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FINISH_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn finish(conn: &Conn, context_tag: ContextTag) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FINISH_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FinishRequest { + context_tag, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -2663,139 +3579,217 @@ impl TryFrom<&[u8]> for FinishReply { /// Opcode for the PixelStoref request pub const PIXEL_STOREF_REQUEST: u8 = 109; +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct PixelStorefRequest { + pub context_tag: ContextTag, + pub pname: u32, + pub datum: Float32, +} +impl PixelStorefRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let pname_bytes = self.pname.serialize(); + let datum_bytes = self.datum.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PIXEL_STOREF_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + datum_bytes[0], + datum_bytes[1], + datum_bytes[2], + datum_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn pixel_storef(conn: &Conn, context_tag: ContextTag, pname: u32, datum: Float32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let pname_bytes = pname.serialize(); - let datum_bytes = datum.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PIXEL_STOREF_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - datum_bytes[0], - datum_bytes[1], - datum_bytes[2], - datum_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PixelStorefRequest { + context_tag, + pname, + datum, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PixelStorei request pub const PIXEL_STOREI_REQUEST: u8 = 110; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PixelStoreiRequest { + pub context_tag: ContextTag, + pub pname: u32, + pub datum: i32, +} +impl PixelStoreiRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let pname_bytes = self.pname.serialize(); + let datum_bytes = self.datum.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PIXEL_STOREI_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + datum_bytes[0], + datum_bytes[1], + datum_bytes[2], + datum_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn pixel_storei(conn: &Conn, context_tag: ContextTag, pname: u32, datum: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let pname_bytes = pname.serialize(); - let datum_bytes = datum.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PIXEL_STOREI_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - datum_bytes[0], - datum_bytes[1], - datum_bytes[2], - datum_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PixelStoreiRequest { + context_tag, + pname, + datum, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ReadPixels request pub const READ_PIXELS_REQUEST: u8 = 111; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ReadPixelsRequest { + pub context_tag: ContextTag, + pub x: i32, + pub y: i32, + pub width: i32, + pub height: i32, + pub format: u32, + pub type_: u32, + pub swap_bytes: bool, + pub lsb_first: bool, +} +impl ReadPixelsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let format_bytes = self.format.serialize(); + let type_bytes = self.type_.serialize(); + let swap_bytes_bytes = self.swap_bytes.serialize(); + let lsb_first_bytes = self.lsb_first.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + READ_PIXELS_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + x_bytes[0], + x_bytes[1], + x_bytes[2], + x_bytes[3], + y_bytes[0], + y_bytes[1], + y_bytes[2], + y_bytes[3], + width_bytes[0], + width_bytes[1], + width_bytes[2], + width_bytes[3], + height_bytes[0], + height_bytes[1], + height_bytes[2], + height_bytes[3], + format_bytes[0], + format_bytes[1], + format_bytes[2], + format_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + swap_bytes_bytes[0], + lsb_first_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn read_pixels(conn: &Conn, context_tag: ContextTag, x: i32, y: i32, width: i32, height: i32, format: u32, type_: u32, swap_bytes: bool, lsb_first: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let format_bytes = format.serialize(); - let type_bytes = type_.serialize(); - let swap_bytes_bytes = swap_bytes.serialize(); - let lsb_first_bytes = lsb_first.serialize(); - let mut request0 = [ - extension_information.major_opcode, - READ_PIXELS_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - x_bytes[0], - x_bytes[1], - x_bytes[2], - x_bytes[3], - y_bytes[0], - y_bytes[1], - y_bytes[2], - y_bytes[3], - width_bytes[0], - width_bytes[1], - width_bytes[2], - width_bytes[3], - height_bytes[0], - height_bytes[1], - height_bytes[2], - height_bytes[3], - format_bytes[0], - format_bytes[1], - format_bytes[2], - format_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - swap_bytes_bytes[0], - lsb_first_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ReadPixelsRequest { + context_tag, + x, + y, + width, + height, + format, + type_, + swap_bytes, + lsb_first, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2842,34 +3836,54 @@ impl ReadPixelsReply { /// Opcode for the GetBooleanv request pub const GET_BOOLEANV_REQUEST: u8 = 112; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetBooleanvRequest { + pub context_tag: ContextTag, + pub pname: i32, +} +impl GetBooleanvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_BOOLEANV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_booleanv(conn: &Conn, context_tag: ContextTag, pname: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_BOOLEANV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetBooleanvRequest { + context_tag, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2919,34 +3933,54 @@ impl GetBooleanvReply { /// Opcode for the GetClipPlane request pub const GET_CLIP_PLANE_REQUEST: u8 = 113; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetClipPlaneRequest { + pub context_tag: ContextTag, + pub plane: i32, +} +impl GetClipPlaneRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let plane_bytes = self.plane.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CLIP_PLANE_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + plane_bytes[0], + plane_bytes[1], + plane_bytes[2], + plane_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_clip_plane(conn: &Conn, context_tag: ContextTag, plane: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let plane_bytes = plane.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CLIP_PLANE_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - plane_bytes[0], - plane_bytes[1], - plane_bytes[2], - plane_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetClipPlaneRequest { + context_tag, + plane, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -2992,34 +4026,54 @@ impl GetClipPlaneReply { /// Opcode for the GetDoublev request pub const GET_DOUBLEV_REQUEST: u8 = 114; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDoublevRequest { + pub context_tag: ContextTag, + pub pname: u32, +} +impl GetDoublevRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DOUBLEV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_doublev(conn: &Conn, context_tag: ContextTag, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DOUBLEV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDoublevRequest { + context_tag, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -3069,29 +4123,47 @@ impl GetDoublevReply { /// Opcode for the GetError request pub const GET_ERROR_REQUEST: u8 = 115; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetErrorRequest { + pub context_tag: ContextTag, +} +impl GetErrorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_ERROR_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_error(conn: &Conn, context_tag: ContextTag) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_ERROR_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetErrorRequest { + context_tag, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -3121,34 +4193,54 @@ impl TryFrom<&[u8]> for GetErrorReply { /// Opcode for the GetFloatv request pub const GET_FLOATV_REQUEST: u8 = 116; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetFloatvRequest { + pub context_tag: ContextTag, + pub pname: u32, +} +impl GetFloatvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_FLOATV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_floatv(conn: &Conn, context_tag: ContextTag, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_FLOATV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetFloatvRequest { + context_tag, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -3198,34 +4290,54 @@ impl GetFloatvReply { /// Opcode for the GetIntegerv request pub const GET_INTEGERV_REQUEST: u8 = 117; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetIntegervRequest { + pub context_tag: ContextTag, + pub pname: u32, +} +impl GetIntegervRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_INTEGERV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_integerv(conn: &Conn, context_tag: ContextTag, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_INTEGERV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetIntegervRequest { + context_tag, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -3275,39 +4387,61 @@ impl GetIntegervReply { /// Opcode for the GetLightfv request pub const GET_LIGHTFV_REQUEST: u8 = 118; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetLightfvRequest { + pub context_tag: ContextTag, + pub light: u32, + pub pname: u32, +} +impl GetLightfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let light_bytes = self.light.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_LIGHTFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + light_bytes[0], + light_bytes[1], + light_bytes[2], + light_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_lightfv(conn: &Conn, context_tag: ContextTag, light: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let light_bytes = light.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_LIGHTFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - light_bytes[0], - light_bytes[1], - light_bytes[2], - light_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetLightfvRequest { + context_tag, + light, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -3357,39 +4491,61 @@ impl GetLightfvReply { /// Opcode for the GetLightiv request pub const GET_LIGHTIV_REQUEST: u8 = 119; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetLightivRequest { + pub context_tag: ContextTag, + pub light: u32, + pub pname: u32, +} +impl GetLightivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let light_bytes = self.light.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_LIGHTIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + light_bytes[0], + light_bytes[1], + light_bytes[2], + light_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_lightiv(conn: &Conn, context_tag: ContextTag, light: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let light_bytes = light.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_LIGHTIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - light_bytes[0], - light_bytes[1], - light_bytes[2], - light_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetLightivRequest { + context_tag, + light, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -3439,39 +4595,61 @@ impl GetLightivReply { /// Opcode for the GetMapdv request pub const GET_MAPDV_REQUEST: u8 = 120; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMapdvRequest { + pub context_tag: ContextTag, + pub target: u32, + pub query: u32, +} +impl GetMapdvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let query_bytes = self.query.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MAPDV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + query_bytes[0], + query_bytes[1], + query_bytes[2], + query_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_mapdv(conn: &Conn, context_tag: ContextTag, target: u32, query: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let query_bytes = query.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MAPDV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - query_bytes[0], - query_bytes[1], - query_bytes[2], - query_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMapdvRequest { + context_tag, + target, + query, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -3521,39 +4699,61 @@ impl GetMapdvReply { /// Opcode for the GetMapfv request pub const GET_MAPFV_REQUEST: u8 = 121; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMapfvRequest { + pub context_tag: ContextTag, + pub target: u32, + pub query: u32, +} +impl GetMapfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let query_bytes = self.query.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MAPFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + query_bytes[0], + query_bytes[1], + query_bytes[2], + query_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_mapfv(conn: &Conn, context_tag: ContextTag, target: u32, query: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let query_bytes = query.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MAPFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - query_bytes[0], - query_bytes[1], - query_bytes[2], - query_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMapfvRequest { + context_tag, + target, + query, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -3603,39 +4803,61 @@ impl GetMapfvReply { /// Opcode for the GetMapiv request pub const GET_MAPIV_REQUEST: u8 = 122; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMapivRequest { + pub context_tag: ContextTag, + pub target: u32, + pub query: u32, +} +impl GetMapivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let query_bytes = self.query.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MAPIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + query_bytes[0], + query_bytes[1], + query_bytes[2], + query_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_mapiv(conn: &Conn, context_tag: ContextTag, target: u32, query: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let query_bytes = query.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MAPIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - query_bytes[0], - query_bytes[1], - query_bytes[2], - query_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMapivRequest { + context_tag, + target, + query, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -3685,39 +4907,61 @@ impl GetMapivReply { /// Opcode for the GetMaterialfv request pub const GET_MATERIALFV_REQUEST: u8 = 123; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMaterialfvRequest { + pub context_tag: ContextTag, + pub face: u32, + pub pname: u32, +} +impl GetMaterialfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let face_bytes = self.face.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MATERIALFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + face_bytes[0], + face_bytes[1], + face_bytes[2], + face_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_materialfv(conn: &Conn, context_tag: ContextTag, face: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let face_bytes = face.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MATERIALFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - face_bytes[0], - face_bytes[1], - face_bytes[2], - face_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMaterialfvRequest { + context_tag, + face, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -3767,39 +5011,61 @@ impl GetMaterialfvReply { /// Opcode for the GetMaterialiv request pub const GET_MATERIALIV_REQUEST: u8 = 124; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMaterialivRequest { + pub context_tag: ContextTag, + pub face: u32, + pub pname: u32, +} +impl GetMaterialivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let face_bytes = self.face.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MATERIALIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + face_bytes[0], + face_bytes[1], + face_bytes[2], + face_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_materialiv(conn: &Conn, context_tag: ContextTag, face: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let face_bytes = face.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MATERIALIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - face_bytes[0], - face_bytes[1], - face_bytes[2], - face_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMaterialivRequest { + context_tag, + face, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -3849,34 +5115,54 @@ impl GetMaterialivReply { /// Opcode for the GetPixelMapfv request pub const GET_PIXEL_MAPFV_REQUEST: u8 = 125; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPixelMapfvRequest { + pub context_tag: ContextTag, + pub map: u32, +} +impl GetPixelMapfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let map_bytes = self.map.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PIXEL_MAPFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + map_bytes[0], + map_bytes[1], + map_bytes[2], + map_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_pixel_mapfv(conn: &Conn, context_tag: ContextTag, map: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let map_bytes = map.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PIXEL_MAPFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - map_bytes[0], - map_bytes[1], - map_bytes[2], - map_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPixelMapfvRequest { + context_tag, + map, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -3926,34 +5212,54 @@ impl GetPixelMapfvReply { /// Opcode for the GetPixelMapuiv request pub const GET_PIXEL_MAPUIV_REQUEST: u8 = 126; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPixelMapuivRequest { + pub context_tag: ContextTag, + pub map: u32, +} +impl GetPixelMapuivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let map_bytes = self.map.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PIXEL_MAPUIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + map_bytes[0], + map_bytes[1], + map_bytes[2], + map_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_pixel_mapuiv(conn: &Conn, context_tag: ContextTag, map: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let map_bytes = map.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PIXEL_MAPUIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - map_bytes[0], - map_bytes[1], - map_bytes[2], - map_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPixelMapuivRequest { + context_tag, + map, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4003,34 +5309,54 @@ impl GetPixelMapuivReply { /// Opcode for the GetPixelMapusv request pub const GET_PIXEL_MAPUSV_REQUEST: u8 = 127; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPixelMapusvRequest { + pub context_tag: ContextTag, + pub map: u32, +} +impl GetPixelMapusvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let map_bytes = self.map.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PIXEL_MAPUSV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + map_bytes[0], + map_bytes[1], + map_bytes[2], + map_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_pixel_mapusv(conn: &Conn, context_tag: ContextTag, map: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let map_bytes = map.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PIXEL_MAPUSV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - map_bytes[0], - map_bytes[1], - map_bytes[2], - map_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPixelMapusvRequest { + context_tag, + map, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4080,34 +5406,54 @@ impl GetPixelMapusvReply { /// Opcode for the GetPolygonStipple request pub const GET_POLYGON_STIPPLE_REQUEST: u8 = 128; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPolygonStippleRequest { + pub context_tag: ContextTag, + pub lsb_first: bool, +} +impl GetPolygonStippleRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let lsb_first_bytes = self.lsb_first.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_POLYGON_STIPPLE_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + lsb_first_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_polygon_stipple(conn: &Conn, context_tag: ContextTag, lsb_first: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let lsb_first_bytes = lsb_first.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_POLYGON_STIPPLE_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - lsb_first_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPolygonStippleRequest { + context_tag, + lsb_first, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4154,34 +5500,54 @@ impl GetPolygonStippleReply { /// Opcode for the GetString request pub const GET_STRING_REQUEST: u8 = 129; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetStringRequest { + pub context_tag: ContextTag, + pub name: u32, +} +impl GetStringRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let name_bytes = self.name.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_STRING_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + name_bytes[0], + name_bytes[1], + name_bytes[2], + name_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_string(conn: &Conn, context_tag: ContextTag, name: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let name_bytes = name.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_STRING_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - name_bytes[0], - name_bytes[1], - name_bytes[2], - name_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetStringRequest { + context_tag, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4230,39 +5596,61 @@ impl GetStringReply { /// Opcode for the GetTexEnvfv request pub const GET_TEX_ENVFV_REQUEST: u8 = 130; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTexEnvfvRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetTexEnvfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_TEX_ENVFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_tex_envfv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_TEX_ENVFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTexEnvfvRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -4312,39 +5700,61 @@ impl GetTexEnvfvReply { /// Opcode for the GetTexEnviv request pub const GET_TEX_ENVIV_REQUEST: u8 = 131; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTexEnvivRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetTexEnvivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_TEX_ENVIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_tex_enviv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_TEX_ENVIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTexEnvivRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4394,39 +5804,61 @@ impl GetTexEnvivReply { /// Opcode for the GetTexGendv request pub const GET_TEX_GENDV_REQUEST: u8 = 132; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTexGendvRequest { + pub context_tag: ContextTag, + pub coord: u32, + pub pname: u32, +} +impl GetTexGendvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let coord_bytes = self.coord.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_TEX_GENDV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + coord_bytes[0], + coord_bytes[1], + coord_bytes[2], + coord_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_tex_gendv(conn: &Conn, context_tag: ContextTag, coord: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let coord_bytes = coord.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_TEX_GENDV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - coord_bytes[0], - coord_bytes[1], - coord_bytes[2], - coord_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTexGendvRequest { + context_tag, + coord, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -4473,42 +5905,64 @@ impl GetTexGendvReply { .try_into().unwrap() } } - -/// Opcode for the GetTexGenfv request -pub const GET_TEX_GENFV_REQUEST: u8 = 133; + +/// Opcode for the GetTexGenfv request +pub const GET_TEX_GENFV_REQUEST: u8 = 133; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTexGenfvRequest { + pub context_tag: ContextTag, + pub coord: u32, + pub pname: u32, +} +impl GetTexGenfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let coord_bytes = self.coord.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_TEX_GENFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + coord_bytes[0], + coord_bytes[1], + coord_bytes[2], + coord_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_tex_genfv(conn: &Conn, context_tag: ContextTag, coord: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let coord_bytes = coord.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_TEX_GENFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - coord_bytes[0], - coord_bytes[1], - coord_bytes[2], - coord_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTexGenfvRequest { + context_tag, + coord, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -4558,39 +6012,61 @@ impl GetTexGenfvReply { /// Opcode for the GetTexGeniv request pub const GET_TEX_GENIV_REQUEST: u8 = 134; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTexGenivRequest { + pub context_tag: ContextTag, + pub coord: u32, + pub pname: u32, +} +impl GetTexGenivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let coord_bytes = self.coord.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_TEX_GENIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + coord_bytes[0], + coord_bytes[1], + coord_bytes[2], + coord_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_tex_geniv(conn: &Conn, context_tag: ContextTag, coord: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let coord_bytes = coord.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_TEX_GENIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - coord_bytes[0], - coord_bytes[1], - coord_bytes[2], - coord_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTexGenivRequest { + context_tag, + coord, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4640,54 +6116,82 @@ impl GetTexGenivReply { /// Opcode for the GetTexImage request pub const GET_TEX_IMAGE_REQUEST: u8 = 135; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTexImageRequest { + pub context_tag: ContextTag, + pub target: u32, + pub level: i32, + pub format: u32, + pub type_: u32, + pub swap_bytes: bool, +} +impl GetTexImageRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let level_bytes = self.level.serialize(); + let format_bytes = self.format.serialize(); + let type_bytes = self.type_.serialize(); + let swap_bytes_bytes = self.swap_bytes.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_TEX_IMAGE_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + level_bytes[0], + level_bytes[1], + level_bytes[2], + level_bytes[3], + format_bytes[0], + format_bytes[1], + format_bytes[2], + format_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + swap_bytes_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_tex_image(conn: &Conn, context_tag: ContextTag, target: u32, level: i32, format: u32, type_: u32, swap_bytes: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let level_bytes = level.serialize(); - let format_bytes = format.serialize(); - let type_bytes = type_.serialize(); - let swap_bytes_bytes = swap_bytes.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_TEX_IMAGE_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - level_bytes[0], - level_bytes[1], - level_bytes[2], - level_bytes[3], - format_bytes[0], - format_bytes[1], - format_bytes[2], - format_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - swap_bytes_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTexImageRequest { + context_tag, + target, + level, + format, + type_, + swap_bytes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4741,39 +6245,61 @@ impl GetTexImageReply { /// Opcode for the GetTexParameterfv request pub const GET_TEX_PARAMETERFV_REQUEST: u8 = 136; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTexParameterfvRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetTexParameterfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_TEX_PARAMETERFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_tex_parameterfv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_TEX_PARAMETERFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTexParameterfvRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -4823,39 +6349,61 @@ impl GetTexParameterfvReply { /// Opcode for the GetTexParameteriv request pub const GET_TEX_PARAMETERIV_REQUEST: u8 = 137; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTexParameterivRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetTexParameterivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_TEX_PARAMETERIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_tex_parameteriv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_TEX_PARAMETERIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTexParameterivRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4905,44 +6453,68 @@ impl GetTexParameterivReply { /// Opcode for the GetTexLevelParameterfv request pub const GET_TEX_LEVEL_PARAMETERFV_REQUEST: u8 = 138; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTexLevelParameterfvRequest { + pub context_tag: ContextTag, + pub target: u32, + pub level: i32, + pub pname: u32, +} +impl GetTexLevelParameterfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let level_bytes = self.level.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_TEX_LEVEL_PARAMETERFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + level_bytes[0], + level_bytes[1], + level_bytes[2], + level_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_tex_level_parameterfv(conn: &Conn, context_tag: ContextTag, target: u32, level: i32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let level_bytes = level.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_TEX_LEVEL_PARAMETERFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - level_bytes[0], - level_bytes[1], - level_bytes[2], - level_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTexLevelParameterfvRequest { + context_tag, + target, + level, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -4992,44 +6564,68 @@ impl GetTexLevelParameterfvReply { /// Opcode for the GetTexLevelParameteriv request pub const GET_TEX_LEVEL_PARAMETERIV_REQUEST: u8 = 139; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetTexLevelParameterivRequest { + pub context_tag: ContextTag, + pub target: u32, + pub level: i32, + pub pname: u32, +} +impl GetTexLevelParameterivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let level_bytes = self.level.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_TEX_LEVEL_PARAMETERIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + level_bytes[0], + level_bytes[1], + level_bytes[2], + level_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_tex_level_parameteriv(conn: &Conn, context_tag: ContextTag, target: u32, level: i32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let level_bytes = level.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_TEX_LEVEL_PARAMETERIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - level_bytes[0], - level_bytes[1], - level_bytes[2], - level_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetTexLevelParameterivRequest { + context_tag, + target, + level, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -5079,34 +6675,54 @@ impl GetTexLevelParameterivReply { /// Opcode for the IsEnabled request pub const IS_ENABLED_REQUEST: u8 = 140; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct IsEnabledRequest { + pub context_tag: ContextTag, + pub capability: u32, +} +impl IsEnabledRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let capability_bytes = self.capability.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + IS_ENABLED_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + capability_bytes[0], + capability_bytes[1], + capability_bytes[2], + capability_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn is_enabled(conn: &Conn, context_tag: ContextTag, capability: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let capability_bytes = capability.serialize(); - let mut request0 = [ - extension_information.major_opcode, - IS_ENABLED_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - capability_bytes[0], - capability_bytes[1], - capability_bytes[2], - capability_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = IsEnabledRequest { + context_tag, + capability, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -5136,34 +6752,54 @@ impl TryFrom<&[u8]> for IsEnabledReply { /// Opcode for the IsList request pub const IS_LIST_REQUEST: u8 = 141; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct IsListRequest { + pub context_tag: ContextTag, + pub list: u32, +} +impl IsListRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let list_bytes = self.list.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + IS_LIST_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + list_bytes[0], + list_bytes[1], + list_bytes[2], + list_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn is_list(conn: &Conn, context_tag: ContextTag, list: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let list_bytes = list.serialize(); - let mut request0 = [ - extension_information.major_opcode, - IS_LIST_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - list_bytes[0], - list_bytes[1], - list_bytes[2], - list_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = IsListRequest { + context_tag, + list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -5193,66 +6829,104 @@ impl TryFrom<&[u8]> for IsListReply { /// Opcode for the Flush request pub const FLUSH_REQUEST: u8 = 142; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FlushRequest { + pub context_tag: ContextTag, +} +impl FlushRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FLUSH_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn flush(conn: &Conn, context_tag: ContextTag) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FLUSH_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FlushRequest { + context_tag, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the AreTexturesResident request pub const ARE_TEXTURES_RESIDENT_REQUEST: u8 = 143; -pub fn are_textures_resident<'c, Conn>(conn: &'c Conn, context_tag: ContextTag, textures: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AreTexturesResidentRequest<'input> { + pub context_tag: ContextTag, + pub textures: &'input [u32], +} +impl<'input> AreTexturesResidentRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let n = i32::try_from(self.textures.len()).expect("`textures` has too many elements"); + let n_bytes = n.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + ARE_TEXTURES_RESIDENT_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + n_bytes[0], + n_bytes[1], + n_bytes[2], + n_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let textures_bytes = self.textures.serialize(); + let length_so_far = length_so_far + textures_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), textures_bytes.into(), padding0.into()], vec![])) + } +} +pub fn are_textures_resident<'c, 'input, Conn>(conn: &'c Conn, context_tag: ContextTag, textures: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let n = i32::try_from(textures.len()).expect("`textures` has too many elements"); - let n_bytes = n.serialize(); - let mut request0 = [ - extension_information.major_opcode, - ARE_TEXTURES_RESIDENT_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - n_bytes[0], - n_bytes[1], - n_bytes[2], - n_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let textures_bytes = textures.serialize(); - let length_so_far = length_so_far + textures_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&textures_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = AreTexturesResidentRequest { + context_tag, + textures, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -5300,71 +6974,111 @@ impl AreTexturesResidentReply { /// Opcode for the DeleteTextures request pub const DELETE_TEXTURES_REQUEST: u8 = 144; -pub fn delete_textures<'c, Conn>(conn: &'c Conn, context_tag: ContextTag, textures: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct DeleteTexturesRequest<'input> { + pub context_tag: ContextTag, + pub textures: &'input [u32], +} +impl<'input> DeleteTexturesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let n = i32::try_from(self.textures.len()).expect("`textures` has too many elements"); + let n_bytes = n.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_TEXTURES_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + n_bytes[0], + n_bytes[1], + n_bytes[2], + n_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let textures_bytes = self.textures.serialize(); + let length_so_far = length_so_far + textures_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), textures_bytes.into(), padding0.into()], vec![])) + } +} +pub fn delete_textures<'c, 'input, Conn>(conn: &'c Conn, context_tag: ContextTag, textures: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let n = i32::try_from(textures.len()).expect("`textures` has too many elements"); - let n_bytes = n.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_TEXTURES_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - n_bytes[0], - n_bytes[1], - n_bytes[2], - n_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let textures_bytes = textures.serialize(); - let length_so_far = length_so_far + textures_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&textures_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = DeleteTexturesRequest { + context_tag, + textures, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GenTextures request pub const GEN_TEXTURES_REQUEST: u8 = 145; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GenTexturesRequest { + pub context_tag: ContextTag, + pub n: i32, +} +impl GenTexturesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let n_bytes = self.n.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GEN_TEXTURES_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + n_bytes[0], + n_bytes[1], + n_bytes[2], + n_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn gen_textures(conn: &Conn, context_tag: ContextTag, n: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let n_bytes = n.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GEN_TEXTURES_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - n_bytes[0], - n_bytes[1], - n_bytes[2], - n_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GenTexturesRequest { + context_tag, + n, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -5409,34 +7123,54 @@ impl GenTexturesReply { /// Opcode for the IsTexture request pub const IS_TEXTURE_REQUEST: u8 = 146; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct IsTextureRequest { + pub context_tag: ContextTag, + pub texture: u32, +} +impl IsTextureRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let texture_bytes = self.texture.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + IS_TEXTURE_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + texture_bytes[0], + texture_bytes[1], + texture_bytes[2], + texture_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn is_texture(conn: &Conn, context_tag: ContextTag, texture: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let texture_bytes = texture.serialize(); - let mut request0 = [ - extension_information.major_opcode, - IS_TEXTURE_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - texture_bytes[0], - texture_bytes[1], - texture_bytes[2], - texture_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = IsTextureRequest { + context_tag, + texture, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -5466,49 +7200,75 @@ impl TryFrom<&[u8]> for IsTextureReply { /// Opcode for the GetColorTable request pub const GET_COLOR_TABLE_REQUEST: u8 = 147; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetColorTableRequest { + pub context_tag: ContextTag, + pub target: u32, + pub format: u32, + pub type_: u32, + pub swap_bytes: bool, +} +impl GetColorTableRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let format_bytes = self.format.serialize(); + let type_bytes = self.type_.serialize(); + let swap_bytes_bytes = self.swap_bytes.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_COLOR_TABLE_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + format_bytes[0], + format_bytes[1], + format_bytes[2], + format_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + swap_bytes_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_color_table(conn: &Conn, context_tag: ContextTag, target: u32, format: u32, type_: u32, swap_bytes: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let format_bytes = format.serialize(); - let type_bytes = type_.serialize(); - let swap_bytes_bytes = swap_bytes.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_COLOR_TABLE_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - format_bytes[0], - format_bytes[1], - format_bytes[2], - format_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - swap_bytes_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetColorTableRequest { + context_tag, + target, + format, + type_, + swap_bytes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -5558,39 +7318,61 @@ impl GetColorTableReply { /// Opcode for the GetColorTableParameterfv request pub const GET_COLOR_TABLE_PARAMETERFV_REQUEST: u8 = 148; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetColorTableParameterfvRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetColorTableParameterfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_COLOR_TABLE_PARAMETERFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_color_table_parameterfv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_COLOR_TABLE_PARAMETERFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetColorTableParameterfvRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -5640,39 +7422,61 @@ impl GetColorTableParameterfvReply { /// Opcode for the GetColorTableParameteriv request pub const GET_COLOR_TABLE_PARAMETERIV_REQUEST: u8 = 149; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetColorTableParameterivRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetColorTableParameterivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_COLOR_TABLE_PARAMETERIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_color_table_parameteriv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_COLOR_TABLE_PARAMETERIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetColorTableParameterivRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -5722,49 +7526,75 @@ impl GetColorTableParameterivReply { /// Opcode for the GetConvolutionFilter request pub const GET_CONVOLUTION_FILTER_REQUEST: u8 = 150; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetConvolutionFilterRequest { + pub context_tag: ContextTag, + pub target: u32, + pub format: u32, + pub type_: u32, + pub swap_bytes: bool, +} +impl GetConvolutionFilterRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let format_bytes = self.format.serialize(); + let type_bytes = self.type_.serialize(); + let swap_bytes_bytes = self.swap_bytes.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CONVOLUTION_FILTER_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + format_bytes[0], + format_bytes[1], + format_bytes[2], + format_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + swap_bytes_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_convolution_filter(conn: &Conn, context_tag: ContextTag, target: u32, format: u32, type_: u32, swap_bytes: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let format_bytes = format.serialize(); - let type_bytes = type_.serialize(); - let swap_bytes_bytes = swap_bytes.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CONVOLUTION_FILTER_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - format_bytes[0], - format_bytes[1], - format_bytes[2], - format_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - swap_bytes_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetConvolutionFilterRequest { + context_tag, + target, + format, + type_, + swap_bytes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -5816,39 +7646,61 @@ impl GetConvolutionFilterReply { /// Opcode for the GetConvolutionParameterfv request pub const GET_CONVOLUTION_PARAMETERFV_REQUEST: u8 = 151; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetConvolutionParameterfvRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetConvolutionParameterfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CONVOLUTION_PARAMETERFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_convolution_parameterfv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CONVOLUTION_PARAMETERFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetConvolutionParameterfvRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -5898,39 +7750,61 @@ impl GetConvolutionParameterfvReply { /// Opcode for the GetConvolutionParameteriv request pub const GET_CONVOLUTION_PARAMETERIV_REQUEST: u8 = 152; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetConvolutionParameterivRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetConvolutionParameterivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CONVOLUTION_PARAMETERIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_convolution_parameteriv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CONVOLUTION_PARAMETERIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetConvolutionParameterivRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -5980,49 +7854,75 @@ impl GetConvolutionParameterivReply { /// Opcode for the GetSeparableFilter request pub const GET_SEPARABLE_FILTER_REQUEST: u8 = 153; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetSeparableFilterRequest { + pub context_tag: ContextTag, + pub target: u32, + pub format: u32, + pub type_: u32, + pub swap_bytes: bool, +} +impl GetSeparableFilterRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let format_bytes = self.format.serialize(); + let type_bytes = self.type_.serialize(); + let swap_bytes_bytes = self.swap_bytes.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SEPARABLE_FILTER_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + format_bytes[0], + format_bytes[1], + format_bytes[2], + format_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + swap_bytes_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_separable_filter(conn: &Conn, context_tag: ContextTag, target: u32, format: u32, type_: u32, swap_bytes: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let format_bytes = format.serialize(); - let type_bytes = type_.serialize(); - let swap_bytes_bytes = swap_bytes.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SEPARABLE_FILTER_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - format_bytes[0], - format_bytes[1], - format_bytes[2], - format_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - swap_bytes_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetSeparableFilterRequest { + context_tag, + target, + format, + type_, + swap_bytes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -6074,50 +7974,78 @@ impl GetSeparableFilterReply { /// Opcode for the GetHistogram request pub const GET_HISTOGRAM_REQUEST: u8 = 154; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetHistogramRequest { + pub context_tag: ContextTag, + pub target: u32, + pub format: u32, + pub type_: u32, + pub swap_bytes: bool, + pub reset: bool, +} +impl GetHistogramRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let format_bytes = self.format.serialize(); + let type_bytes = self.type_.serialize(); + let swap_bytes_bytes = self.swap_bytes.serialize(); + let reset_bytes = self.reset.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_HISTOGRAM_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + format_bytes[0], + format_bytes[1], + format_bytes[2], + format_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + swap_bytes_bytes[0], + reset_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_histogram(conn: &Conn, context_tag: ContextTag, target: u32, format: u32, type_: u32, swap_bytes: bool, reset: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let format_bytes = format.serialize(); - let type_bytes = type_.serialize(); - let swap_bytes_bytes = swap_bytes.serialize(); - let reset_bytes = reset.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_HISTOGRAM_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - format_bytes[0], - format_bytes[1], - format_bytes[2], - format_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - swap_bytes_bytes[0], - reset_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetHistogramRequest { + context_tag, + target, + format, + type_, + swap_bytes, + reset, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -6167,39 +8095,61 @@ impl GetHistogramReply { /// Opcode for the GetHistogramParameterfv request pub const GET_HISTOGRAM_PARAMETERFV_REQUEST: u8 = 155; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetHistogramParameterfvRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetHistogramParameterfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_HISTOGRAM_PARAMETERFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_histogram_parameterfv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_HISTOGRAM_PARAMETERFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetHistogramParameterfvRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -6249,39 +8199,61 @@ impl GetHistogramParameterfvReply { /// Opcode for the GetHistogramParameteriv request pub const GET_HISTOGRAM_PARAMETERIV_REQUEST: u8 = 156; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetHistogramParameterivRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetHistogramParameterivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_HISTOGRAM_PARAMETERIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_histogram_parameteriv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_HISTOGRAM_PARAMETERIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetHistogramParameterivRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -6331,50 +8303,78 @@ impl GetHistogramParameterivReply { /// Opcode for the GetMinmax request pub const GET_MINMAX_REQUEST: u8 = 157; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMinmaxRequest { + pub context_tag: ContextTag, + pub target: u32, + pub format: u32, + pub type_: u32, + pub swap_bytes: bool, + pub reset: bool, +} +impl GetMinmaxRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let format_bytes = self.format.serialize(); + let type_bytes = self.type_.serialize(); + let swap_bytes_bytes = self.swap_bytes.serialize(); + let reset_bytes = self.reset.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MINMAX_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + format_bytes[0], + format_bytes[1], + format_bytes[2], + format_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + swap_bytes_bytes[0], + reset_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_minmax(conn: &Conn, context_tag: ContextTag, target: u32, format: u32, type_: u32, swap_bytes: bool, reset: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let format_bytes = format.serialize(); - let type_bytes = type_.serialize(); - let swap_bytes_bytes = swap_bytes.serialize(); - let reset_bytes = reset.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MINMAX_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - format_bytes[0], - format_bytes[1], - format_bytes[2], - format_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - swap_bytes_bytes[0], - reset_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMinmaxRequest { + context_tag, + target, + format, + type_, + swap_bytes, + reset, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -6421,39 +8421,61 @@ impl GetMinmaxReply { /// Opcode for the GetMinmaxParameterfv request pub const GET_MINMAX_PARAMETERFV_REQUEST: u8 = 158; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMinmaxParameterfvRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetMinmaxParameterfvRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MINMAX_PARAMETERFV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_minmax_parameterfv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MINMAX_PARAMETERFV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMinmaxParameterfvRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq)] @@ -6503,39 +8525,61 @@ impl GetMinmaxParameterfvReply { /// Opcode for the GetMinmaxParameteriv request pub const GET_MINMAX_PARAMETERIV_REQUEST: u8 = 159; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMinmaxParameterivRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetMinmaxParameterivRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MINMAX_PARAMETERIV_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_minmax_parameteriv(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MINMAX_PARAMETERIV_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMinmaxParameterivRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -6585,39 +8629,61 @@ impl GetMinmaxParameterivReply { /// Opcode for the GetCompressedTexImageARB request pub const GET_COMPRESSED_TEX_IMAGE_ARB_REQUEST: u8 = 160; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetCompressedTexImageARBRequest { + pub context_tag: ContextTag, + pub target: u32, + pub level: i32, +} +impl GetCompressedTexImageARBRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let level_bytes = self.level.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_COMPRESSED_TEX_IMAGE_ARB_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + level_bytes[0], + level_bytes[1], + level_bytes[2], + level_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_compressed_tex_image_arb(conn: &Conn, context_tag: ContextTag, target: u32, level: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let level_bytes = level.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_COMPRESSED_TEX_IMAGE_ARB_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - level_bytes[0], - level_bytes[1], - level_bytes[2], - level_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetCompressedTexImageARBRequest { + context_tag, + target, + level, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -6667,71 +8733,111 @@ impl GetCompressedTexImageARBReply { /// Opcode for the DeleteQueriesARB request pub const DELETE_QUERIES_ARB_REQUEST: u8 = 161; -pub fn delete_queries_arb<'c, Conn>(conn: &'c Conn, context_tag: ContextTag, ids: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct DeleteQueriesARBRequest<'input> { + pub context_tag: ContextTag, + pub ids: &'input [u32], +} +impl<'input> DeleteQueriesARBRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let n = i32::try_from(self.ids.len()).expect("`ids` has too many elements"); + let n_bytes = n.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_QUERIES_ARB_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + n_bytes[0], + n_bytes[1], + n_bytes[2], + n_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let ids_bytes = self.ids.serialize(); + let length_so_far = length_so_far + ids_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), ids_bytes.into(), padding0.into()], vec![])) + } +} +pub fn delete_queries_arb<'c, 'input, Conn>(conn: &'c Conn, context_tag: ContextTag, ids: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let n = i32::try_from(ids.len()).expect("`ids` has too many elements"); - let n_bytes = n.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_QUERIES_ARB_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - n_bytes[0], - n_bytes[1], - n_bytes[2], - n_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let ids_bytes = ids.serialize(); - let length_so_far = length_so_far + ids_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&ids_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = DeleteQueriesARBRequest { + context_tag, + ids, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GenQueriesARB request pub const GEN_QUERIES_ARB_REQUEST: u8 = 162; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GenQueriesARBRequest { + pub context_tag: ContextTag, + pub n: i32, +} +impl GenQueriesARBRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let n_bytes = self.n.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GEN_QUERIES_ARB_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + n_bytes[0], + n_bytes[1], + n_bytes[2], + n_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn gen_queries_arb(conn: &Conn, context_tag: ContextTag, n: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let n_bytes = n.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GEN_QUERIES_ARB_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - n_bytes[0], - n_bytes[1], - n_bytes[2], - n_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GenQueriesARBRequest { + context_tag, + n, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -6776,34 +8882,54 @@ impl GenQueriesARBReply { /// Opcode for the IsQueryARB request pub const IS_QUERY_ARB_REQUEST: u8 = 163; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct IsQueryARBRequest { + pub context_tag: ContextTag, + pub id: u32, +} +impl IsQueryARBRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let id_bytes = self.id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + IS_QUERY_ARB_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn is_query_arb(conn: &Conn, context_tag: ContextTag, id: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let id_bytes = id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - IS_QUERY_ARB_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = IsQueryARBRequest { + context_tag, + id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -6833,39 +8959,61 @@ impl TryFrom<&[u8]> for IsQueryARBReply { /// Opcode for the GetQueryivARB request pub const GET_QUERYIV_ARB_REQUEST: u8 = 164; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetQueryivARBRequest { + pub context_tag: ContextTag, + pub target: u32, + pub pname: u32, +} +impl GetQueryivARBRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let target_bytes = self.target.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_QUERYIV_ARB_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_queryiv_arb(conn: &Conn, context_tag: ContextTag, target: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let target_bytes = target.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_QUERYIV_ARB_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetQueryivARBRequest { + context_tag, + target, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -6915,39 +9063,61 @@ impl GetQueryivARBReply { /// Opcode for the GetQueryObjectivARB request pub const GET_QUERY_OBJECTIV_ARB_REQUEST: u8 = 165; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetQueryObjectivARBRequest { + pub context_tag: ContextTag, + pub id: u32, + pub pname: u32, +} +impl GetQueryObjectivARBRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let id_bytes = self.id.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_QUERY_OBJECTIV_ARB_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_query_objectiv_arb(conn: &Conn, context_tag: ContextTag, id: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let id_bytes = id.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_QUERY_OBJECTIV_ARB_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetQueryObjectivARBRequest { + context_tag, + id, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -6997,39 +9167,61 @@ impl GetQueryObjectivARBReply { /// Opcode for the GetQueryObjectuivARB request pub const GET_QUERY_OBJECTUIV_ARB_REQUEST: u8 = 166; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetQueryObjectuivARBRequest { + pub context_tag: ContextTag, + pub id: u32, + pub pname: u32, +} +impl GetQueryObjectuivARBRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_tag_bytes = self.context_tag.serialize(); + let id_bytes = self.id.serialize(); + let pname_bytes = self.pname.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_QUERY_OBJECTUIV_ARB_REQUEST, + 0, + 0, + context_tag_bytes[0], + context_tag_bytes[1], + context_tag_bytes[2], + context_tag_bytes[3], + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + pname_bytes[0], + pname_bytes[1], + pname_bytes[2], + pname_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_query_objectuiv_arb(conn: &Conn, context_tag: ContextTag, id: u32, pname: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_tag_bytes = context_tag.serialize(); - let id_bytes = id.serialize(); - let pname_bytes = pname.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_QUERY_OBJECTUIV_ARB_REQUEST, - 0, - 0, - context_tag_bytes[0], - context_tag_bytes[1], - context_tag_bytes[2], - context_tag_bytes[3], - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - pname_bytes[0], - pname_bytes[1], - pname_bytes[2], - pname_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetQueryObjectuivARBRequest { + context_tag, + id, + pname, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -7079,11 +9271,11 @@ impl GetQueryObjectuivARBReply { /// Extension trait defining the requests of this extension. pub trait ConnectionExt: RequestConnection { - fn glx_render<'c>(&'c self, context_tag: ContextTag, data: &[u8]) -> Result, ConnectionError> + fn glx_render<'c, 'input>(&'c self, context_tag: ContextTag, data: &'input [u8]) -> Result, ConnectionError> { render(self, context_tag, data) } - fn glx_render_large<'c>(&'c self, context_tag: ContextTag, request_num: u16, request_total: u16, data: &[u8]) -> Result, ConnectionError> + fn glx_render_large<'c, 'input>(&'c self, context_tag: ContextTag, request_num: u16, request_total: u16, data: &'input [u8]) -> Result, ConnectionError> { render_large(self, context_tag, request_num, request_total, data) } @@ -7139,11 +9331,11 @@ pub trait ConnectionExt: RequestConnection { { destroy_glx_pixmap(self, glx_pixmap) } - fn glx_vendor_private<'c>(&'c self, vendor_code: u32, context_tag: ContextTag, data: &[u8]) -> Result, ConnectionError> + fn glx_vendor_private<'c, 'input>(&'c self, vendor_code: u32, context_tag: ContextTag, data: &'input [u8]) -> Result, ConnectionError> { vendor_private(self, vendor_code, context_tag, data) } - fn glx_vendor_private_with_reply<'c>(&'c self, vendor_code: u32, context_tag: ContextTag, data: &[u8]) -> Result, ConnectionError> + fn glx_vendor_private_with_reply<'c, 'input>(&'c self, vendor_code: u32, context_tag: ContextTag, data: &'input [u8]) -> Result, ConnectionError> { vendor_private_with_reply(self, vendor_code, context_tag, data) } @@ -7155,7 +9347,7 @@ pub trait ConnectionExt: RequestConnection { { query_server_string(self, screen, name) } - fn glx_client_info<'c>(&'c self, major_version: u32, minor_version: u32, string: &[u8]) -> Result, ConnectionError> + fn glx_client_info<'c, 'input>(&'c self, major_version: u32, minor_version: u32, string: &'input [u8]) -> Result, ConnectionError> { client_info(self, major_version, minor_version, string) } @@ -7163,7 +9355,7 @@ pub trait ConnectionExt: RequestConnection { { get_fb_configs(self, screen) } - fn glx_create_pixmap<'c>(&'c self, screen: u32, fbconfig: Fbconfig, pixmap: xproto::Pixmap, glx_pixmap: Pixmap, attribs: &[u32]) -> Result, ConnectionError> + fn glx_create_pixmap<'c, 'input>(&'c self, screen: u32, fbconfig: Fbconfig, pixmap: xproto::Pixmap, glx_pixmap: Pixmap, attribs: &'input [u32]) -> Result, ConnectionError> { create_pixmap(self, screen, fbconfig, pixmap, glx_pixmap, attribs) } @@ -7183,7 +9375,7 @@ pub trait ConnectionExt: RequestConnection { { make_context_current(self, old_context_tag, drawable, read_drawable, context) } - fn glx_create_pbuffer<'c>(&'c self, screen: u32, fbconfig: Fbconfig, pbuffer: Pbuffer, attribs: &[u32]) -> Result, ConnectionError> + fn glx_create_pbuffer<'c, 'input>(&'c self, screen: u32, fbconfig: Fbconfig, pbuffer: Pbuffer, attribs: &'input [u32]) -> Result, ConnectionError> { create_pbuffer(self, screen, fbconfig, pbuffer, attribs) } @@ -7195,11 +9387,11 @@ pub trait ConnectionExt: RequestConnection { { get_drawable_attributes(self, drawable) } - fn glx_change_drawable_attributes<'c>(&'c self, drawable: Drawable, attribs: &[u32]) -> Result, ConnectionError> + fn glx_change_drawable_attributes<'c, 'input>(&'c self, drawable: Drawable, attribs: &'input [u32]) -> Result, ConnectionError> { change_drawable_attributes(self, drawable, attribs) } - fn glx_create_window<'c>(&'c self, screen: u32, fbconfig: Fbconfig, window: xproto::Window, glx_window: Window, attribs: &[u32]) -> Result, ConnectionError> + fn glx_create_window<'c, 'input>(&'c self, screen: u32, fbconfig: Fbconfig, window: xproto::Window, glx_window: Window, attribs: &'input [u32]) -> Result, ConnectionError> { create_window(self, screen, fbconfig, window, glx_window, attribs) } @@ -7207,15 +9399,15 @@ pub trait ConnectionExt: RequestConnection { { delete_window(self, glxwindow) } - fn glx_set_client_info_arb<'c>(&'c self, major_version: u32, minor_version: u32, gl_versions: &[u32], gl_extension_string: &[u8], glx_extension_string: &[u8]) -> Result, ConnectionError> + fn glx_set_client_info_arb<'c, 'input>(&'c self, major_version: u32, minor_version: u32, gl_versions: &'input [u32], gl_extension_string: &'input [u8], glx_extension_string: &'input [u8]) -> Result, ConnectionError> { set_client_info_arb(self, major_version, minor_version, gl_versions, gl_extension_string, glx_extension_string) } - fn glx_create_context_attribs_arb<'c>(&'c self, context: Context, fbconfig: Fbconfig, screen: u32, share_list: Context, is_direct: bool, attribs: &[u32]) -> Result, ConnectionError> + fn glx_create_context_attribs_arb<'c, 'input>(&'c self, context: Context, fbconfig: Fbconfig, screen: u32, share_list: Context, is_direct: bool, attribs: &'input [u32]) -> Result, ConnectionError> { create_context_attribs_arb(self, context, fbconfig, screen, share_list, is_direct, attribs) } - fn glx_set_client_info2_arb<'c>(&'c self, major_version: u32, minor_version: u32, gl_versions: &[u32], gl_extension_string: &[u8], glx_extension_string: &[u8]) -> Result, ConnectionError> + fn glx_set_client_info2_arb<'c, 'input>(&'c self, major_version: u32, minor_version: u32, gl_versions: &'input [u32], gl_extension_string: &'input [u8], glx_extension_string: &'input [u8]) -> Result, ConnectionError> { set_client_info2_arb(self, major_version, minor_version, gl_versions, gl_extension_string, glx_extension_string) } @@ -7387,11 +9579,11 @@ pub trait ConnectionExt: RequestConnection { { flush(self, context_tag) } - fn glx_are_textures_resident<'c>(&'c self, context_tag: ContextTag, textures: &[u32]) -> Result, ConnectionError> + fn glx_are_textures_resident<'c, 'input>(&'c self, context_tag: ContextTag, textures: &'input [u32]) -> Result, ConnectionError> { are_textures_resident(self, context_tag, textures) } - fn glx_delete_textures<'c>(&'c self, context_tag: ContextTag, textures: &[u32]) -> Result, ConnectionError> + fn glx_delete_textures<'c, 'input>(&'c self, context_tag: ContextTag, textures: &'input [u32]) -> Result, ConnectionError> { delete_textures(self, context_tag, textures) } @@ -7459,7 +9651,7 @@ pub trait ConnectionExt: RequestConnection { { get_compressed_tex_image_arb(self, context_tag, target, level) } - fn glx_delete_queries_arb<'c>(&'c self, context_tag: ContextTag, ids: &[u32]) -> Result, ConnectionError> + fn glx_delete_queries_arb<'c, 'input>(&'c self, context_tag: ContextTag, ids: &'input [u32]) -> Result, ConnectionError> { delete_queries_arb(self, context_tag, ids) } diff --git a/src/protocol/present.rs b/src/protocol/present.rs index 96c30f40..8fe90f54 100644 --- a/src/protocol/present.rs +++ b/src/protocol/present.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -501,34 +501,54 @@ impl Serialize for Notify { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub major_version: u32, + pub minor_version: u32, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + major_version_bytes[0], + major_version_bytes[1], + major_version_bytes[2], + major_version_bytes[3], + minor_version_bytes[0], + minor_version_bytes[1], + minor_version_bytes[2], + minor_version_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, major_version: u32, minor_version: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - major_version_bytes[0], - major_version_bytes[1], - major_version_bytes[2], - major_version_bytes[3], - minor_version_bytes[0], - minor_version_bytes[1], - minor_version_bytes[2], - minor_version_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + major_version, + minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -560,241 +580,353 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the Pixmap request pub const PIXMAP_REQUEST: u8 = 1; -pub fn pixmap<'c, Conn>(conn: &'c Conn, window: xproto::Window, pixmap: xproto::Pixmap, serial: u32, valid: xfixes::Region, update: xfixes::Region, x_off: i16, y_off: i16, target_crtc: randr::Crtc, wait_fence: sync::Fence, idle_fence: sync::Fence, options: u32, target_msc: u64, divisor: u64, remainder: u64, notifies: &[Notify]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PixmapRequest<'input> { + pub window: xproto::Window, + pub pixmap: xproto::Pixmap, + pub serial: u32, + pub valid: xfixes::Region, + pub update: xfixes::Region, + pub x_off: i16, + pub y_off: i16, + pub target_crtc: randr::Crtc, + pub wait_fence: sync::Fence, + pub idle_fence: sync::Fence, + pub options: u32, + pub target_msc: u64, + pub divisor: u64, + pub remainder: u64, + pub notifies: &'input [Notify], +} +impl<'input> PixmapRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let pixmap_bytes = self.pixmap.serialize(); + let serial_bytes = self.serial.serialize(); + let valid_bytes = self.valid.serialize(); + let update_bytes = self.update.serialize(); + let x_off_bytes = self.x_off.serialize(); + let y_off_bytes = self.y_off.serialize(); + let target_crtc_bytes = self.target_crtc.serialize(); + let wait_fence_bytes = self.wait_fence.serialize(); + let idle_fence_bytes = self.idle_fence.serialize(); + let options_bytes = self.options.serialize(); + let target_msc_bytes = self.target_msc.serialize(); + let divisor_bytes = self.divisor.serialize(); + let remainder_bytes = self.remainder.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PIXMAP_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + pixmap_bytes[0], + pixmap_bytes[1], + pixmap_bytes[2], + pixmap_bytes[3], + serial_bytes[0], + serial_bytes[1], + serial_bytes[2], + serial_bytes[3], + valid_bytes[0], + valid_bytes[1], + valid_bytes[2], + valid_bytes[3], + update_bytes[0], + update_bytes[1], + update_bytes[2], + update_bytes[3], + x_off_bytes[0], + x_off_bytes[1], + y_off_bytes[0], + y_off_bytes[1], + target_crtc_bytes[0], + target_crtc_bytes[1], + target_crtc_bytes[2], + target_crtc_bytes[3], + wait_fence_bytes[0], + wait_fence_bytes[1], + wait_fence_bytes[2], + wait_fence_bytes[3], + idle_fence_bytes[0], + idle_fence_bytes[1], + idle_fence_bytes[2], + idle_fence_bytes[3], + options_bytes[0], + options_bytes[1], + options_bytes[2], + options_bytes[3], + 0, + 0, + 0, + 0, + target_msc_bytes[0], + target_msc_bytes[1], + target_msc_bytes[2], + target_msc_bytes[3], + target_msc_bytes[4], + target_msc_bytes[5], + target_msc_bytes[6], + target_msc_bytes[7], + divisor_bytes[0], + divisor_bytes[1], + divisor_bytes[2], + divisor_bytes[3], + divisor_bytes[4], + divisor_bytes[5], + divisor_bytes[6], + divisor_bytes[7], + remainder_bytes[0], + remainder_bytes[1], + remainder_bytes[2], + remainder_bytes[3], + remainder_bytes[4], + remainder_bytes[5], + remainder_bytes[6], + remainder_bytes[7], + ]; + let length_so_far = length_so_far + request0.len(); + let notifies_bytes = self.notifies.serialize(); + let length_so_far = length_so_far + notifies_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), notifies_bytes.into(), padding0.into()], vec![])) + } +} +pub fn pixmap<'c, 'input, Conn>(conn: &'c Conn, window: xproto::Window, pixmap: xproto::Pixmap, serial: u32, valid: xfixes::Region, update: xfixes::Region, x_off: i16, y_off: i16, target_crtc: randr::Crtc, wait_fence: sync::Fence, idle_fence: sync::Fence, options: u32, target_msc: u64, divisor: u64, remainder: u64, notifies: &'input [Notify]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let pixmap_bytes = pixmap.serialize(); - let serial_bytes = serial.serialize(); - let valid_bytes = valid.serialize(); - let update_bytes = update.serialize(); - let x_off_bytes = x_off.serialize(); - let y_off_bytes = y_off.serialize(); - let target_crtc_bytes = target_crtc.serialize(); - let wait_fence_bytes = wait_fence.serialize(); - let idle_fence_bytes = idle_fence.serialize(); - let options_bytes = options.serialize(); - let target_msc_bytes = target_msc.serialize(); - let divisor_bytes = divisor.serialize(); - let remainder_bytes = remainder.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PIXMAP_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - pixmap_bytes[0], - pixmap_bytes[1], - pixmap_bytes[2], - pixmap_bytes[3], - serial_bytes[0], - serial_bytes[1], - serial_bytes[2], - serial_bytes[3], - valid_bytes[0], - valid_bytes[1], - valid_bytes[2], - valid_bytes[3], - update_bytes[0], - update_bytes[1], - update_bytes[2], - update_bytes[3], - x_off_bytes[0], - x_off_bytes[1], - y_off_bytes[0], - y_off_bytes[1], - target_crtc_bytes[0], - target_crtc_bytes[1], - target_crtc_bytes[2], - target_crtc_bytes[3], - wait_fence_bytes[0], - wait_fence_bytes[1], - wait_fence_bytes[2], - wait_fence_bytes[3], - idle_fence_bytes[0], - idle_fence_bytes[1], - idle_fence_bytes[2], - idle_fence_bytes[3], - options_bytes[0], - options_bytes[1], - options_bytes[2], - options_bytes[3], - 0, - 0, - 0, - 0, - target_msc_bytes[0], - target_msc_bytes[1], - target_msc_bytes[2], - target_msc_bytes[3], - target_msc_bytes[4], - target_msc_bytes[5], - target_msc_bytes[6], - target_msc_bytes[7], - divisor_bytes[0], - divisor_bytes[1], - divisor_bytes[2], - divisor_bytes[3], - divisor_bytes[4], - divisor_bytes[5], - divisor_bytes[6], - divisor_bytes[7], - remainder_bytes[0], - remainder_bytes[1], - remainder_bytes[2], - remainder_bytes[3], - remainder_bytes[4], - remainder_bytes[5], - remainder_bytes[6], - remainder_bytes[7], - ]; - let length_so_far = length_so_far + request0.len(); - let notifies_bytes = notifies.serialize(); - let length_so_far = length_so_far + notifies_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(¬ifies_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = PixmapRequest { + window, + pixmap, + serial, + valid, + update, + x_off, + y_off, + target_crtc, + wait_fence, + idle_fence, + options, + target_msc, + divisor, + remainder, + notifies, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the NotifyMSC request pub const NOTIFY_MSC_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct NotifyMSCRequest { + pub window: xproto::Window, + pub serial: u32, + pub target_msc: u64, + pub divisor: u64, + pub remainder: u64, +} +impl NotifyMSCRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let serial_bytes = self.serial.serialize(); + let target_msc_bytes = self.target_msc.serialize(); + let divisor_bytes = self.divisor.serialize(); + let remainder_bytes = self.remainder.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + NOTIFY_MSC_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + serial_bytes[0], + serial_bytes[1], + serial_bytes[2], + serial_bytes[3], + 0, + 0, + 0, + 0, + target_msc_bytes[0], + target_msc_bytes[1], + target_msc_bytes[2], + target_msc_bytes[3], + target_msc_bytes[4], + target_msc_bytes[5], + target_msc_bytes[6], + target_msc_bytes[7], + divisor_bytes[0], + divisor_bytes[1], + divisor_bytes[2], + divisor_bytes[3], + divisor_bytes[4], + divisor_bytes[5], + divisor_bytes[6], + divisor_bytes[7], + remainder_bytes[0], + remainder_bytes[1], + remainder_bytes[2], + remainder_bytes[3], + remainder_bytes[4], + remainder_bytes[5], + remainder_bytes[6], + remainder_bytes[7], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn notify_msc(conn: &Conn, window: xproto::Window, serial: u32, target_msc: u64, divisor: u64, remainder: u64) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let serial_bytes = serial.serialize(); - let target_msc_bytes = target_msc.serialize(); - let divisor_bytes = divisor.serialize(); - let remainder_bytes = remainder.serialize(); - let mut request0 = [ - extension_information.major_opcode, - NOTIFY_MSC_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - serial_bytes[0], - serial_bytes[1], - serial_bytes[2], - serial_bytes[3], - 0, - 0, - 0, - 0, - target_msc_bytes[0], - target_msc_bytes[1], - target_msc_bytes[2], - target_msc_bytes[3], - target_msc_bytes[4], - target_msc_bytes[5], - target_msc_bytes[6], - target_msc_bytes[7], - divisor_bytes[0], - divisor_bytes[1], - divisor_bytes[2], - divisor_bytes[3], - divisor_bytes[4], - divisor_bytes[5], - divisor_bytes[6], - divisor_bytes[7], - remainder_bytes[0], - remainder_bytes[1], - remainder_bytes[2], - remainder_bytes[3], - remainder_bytes[4], - remainder_bytes[5], - remainder_bytes[6], - remainder_bytes[7], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = NotifyMSCRequest { + window, + serial, + target_msc, + divisor, + remainder, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } pub type Event = u32; /// Opcode for the SelectInput request pub const SELECT_INPUT_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectInputRequest { + pub eid: Event, + pub window: xproto::Window, + pub event_mask: u32, +} +impl SelectInputRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let eid_bytes = self.eid.serialize(); + let window_bytes = self.window.serialize(); + let event_mask_bytes = self.event_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_INPUT_REQUEST, + 0, + 0, + eid_bytes[0], + eid_bytes[1], + eid_bytes[2], + eid_bytes[3], + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + event_mask_bytes[0], + event_mask_bytes[1], + event_mask_bytes[2], + event_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn select_input(conn: &Conn, eid: Event, window: xproto::Window, event_mask: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let event_mask: u32 = event_mask.into(); - let length_so_far = 0; - let eid_bytes = eid.serialize(); - let window_bytes = window.serialize(); - let event_mask_bytes = event_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_INPUT_REQUEST, - 0, - 0, - eid_bytes[0], - eid_bytes[1], - eid_bytes[2], - eid_bytes[3], - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - event_mask_bytes[0], - event_mask_bytes[1], - event_mask_bytes[2], - event_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SelectInputRequest { + eid, + window, + event_mask, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the QueryCapabilities request pub const QUERY_CAPABILITIES_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryCapabilitiesRequest { + pub target: u32, +} +impl QueryCapabilitiesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let target_bytes = self.target.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_CAPABILITIES_REQUEST, + 0, + 0, + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_capabilities(conn: &Conn, target: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let target_bytes = target.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_CAPABILITIES_REQUEST, - 0, - 0, - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryCapabilitiesRequest { + target, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1120,7 +1252,7 @@ pub trait ConnectionExt: RequestConnection { { query_version(self, major_version, minor_version) } - fn present_pixmap<'c>(&'c self, window: xproto::Window, pixmap: xproto::Pixmap, serial: u32, valid: xfixes::Region, update: xfixes::Region, x_off: i16, y_off: i16, target_crtc: randr::Crtc, wait_fence: sync::Fence, idle_fence: sync::Fence, options: u32, target_msc: u64, divisor: u64, remainder: u64, notifies: &[Notify]) -> Result, ConnectionError> + fn present_pixmap<'c, 'input>(&'c self, window: xproto::Window, pixmap: xproto::Pixmap, serial: u32, valid: xfixes::Region, update: xfixes::Region, x_off: i16, y_off: i16, target_crtc: randr::Crtc, wait_fence: sync::Fence, idle_fence: sync::Fence, options: u32, target_msc: u64, divisor: u64, remainder: u64, notifies: &'input [Notify]) -> Result, ConnectionError> { self::pixmap(self, window, pixmap, serial, valid, update, x_off, y_off, target_crtc, wait_fence, idle_fence, options, target_msc, divisor, remainder, notifies) } diff --git a/src/protocol/randr.rs b/src/protocol/randr.rs index d02552c1..d0622db3 100644 --- a/src/protocol/randr.rs +++ b/src/protocol/randr.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -502,34 +502,54 @@ impl RefreshRates { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub major_version: u32, + pub minor_version: u32, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + major_version_bytes[0], + major_version_bytes[1], + major_version_bytes[2], + major_version_bytes[3], + minor_version_bytes[0], + minor_version_bytes[1], + minor_version_bytes[2], + minor_version_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, major_version: u32, minor_version: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - major_version_bytes[0], - major_version_bytes[1], - major_version_bytes[2], - major_version_bytes[3], - minor_version_bytes[0], - minor_version_bytes[1], - minor_version_bytes[2], - minor_version_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + major_version, + minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -630,52 +650,80 @@ impl TryFrom for SetConfig { /// Opcode for the SetScreenConfig request pub const SET_SCREEN_CONFIG_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetScreenConfigRequest { + pub window: xproto::Window, + pub timestamp: xproto::Timestamp, + pub config_timestamp: xproto::Timestamp, + pub size_id: u16, + pub rotation: u16, + pub rate: u16, +} +impl SetScreenConfigRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let timestamp_bytes = self.timestamp.serialize(); + let config_timestamp_bytes = self.config_timestamp.serialize(); + let size_id_bytes = self.size_id.serialize(); + let rotation_bytes = self.rotation.serialize(); + let rate_bytes = self.rate.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_SCREEN_CONFIG_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + timestamp_bytes[0], + timestamp_bytes[1], + timestamp_bytes[2], + timestamp_bytes[3], + config_timestamp_bytes[0], + config_timestamp_bytes[1], + config_timestamp_bytes[2], + config_timestamp_bytes[3], + size_id_bytes[0], + size_id_bytes[1], + rotation_bytes[0], + rotation_bytes[1], + rate_bytes[0], + rate_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_screen_config(conn: &Conn, window: xproto::Window, timestamp: xproto::Timestamp, config_timestamp: xproto::Timestamp, size_id: u16, rotation: A, rate: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let rotation: u16 = rotation.into(); - let length_so_far = 0; - let window_bytes = window.serialize(); - let timestamp_bytes = timestamp.serialize(); - let config_timestamp_bytes = config_timestamp.serialize(); - let size_id_bytes = size_id.serialize(); - let rotation_bytes = rotation.serialize(); - let rate_bytes = rate.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_SCREEN_CONFIG_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - timestamp_bytes[0], - timestamp_bytes[1], - timestamp_bytes[2], - timestamp_bytes[3], - config_timestamp_bytes[0], - config_timestamp_bytes[1], - config_timestamp_bytes[2], - config_timestamp_bytes[3], - size_id_bytes[0], - size_id_bytes[1], - rotation_bytes[0], - rotation_bytes[1], - rate_bytes[0], - rate_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetScreenConfigRequest { + window, + timestamp, + config_timestamp, + size_id, + rotation, + rate, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -796,63 +844,101 @@ bitmask_binop!(NotifyMask, u8); /// Opcode for the SelectInput request pub const SELECT_INPUT_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectInputRequest { + pub window: xproto::Window, + pub enable: u16, +} +impl SelectInputRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let enable_bytes = self.enable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_INPUT_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + enable_bytes[0], + enable_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn select_input(conn: &Conn, window: xproto::Window, enable: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let enable: u16 = enable.into(); - let length_so_far = 0; - let window_bytes = window.serialize(); - let enable_bytes = enable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_INPUT_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - enable_bytes[0], - enable_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SelectInputRequest { + window, + enable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetScreenInfo request pub const GET_SCREEN_INFO_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetScreenInfoRequest { + pub window: xproto::Window, +} +impl GetScreenInfoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SCREEN_INFO_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_screen_info(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SCREEN_INFO_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetScreenInfoRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -916,29 +1002,47 @@ impl GetScreenInfoReply { /// Opcode for the GetScreenSizeRange request pub const GET_SCREEN_SIZE_RANGE_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetScreenSizeRangeRequest { + pub window: xproto::Window, +} +impl GetScreenSizeRangeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SCREEN_SIZE_RANGE_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_screen_size_range(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SCREEN_SIZE_RANGE_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetScreenSizeRangeRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -975,45 +1079,71 @@ impl TryFrom<&[u8]> for GetScreenSizeRangeReply { /// Opcode for the SetScreenSize request pub const SET_SCREEN_SIZE_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetScreenSizeRequest { + pub window: xproto::Window, + pub width: u16, + pub height: u16, + pub mm_width: u32, + pub mm_height: u32, +} +impl SetScreenSizeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let mm_width_bytes = self.mm_width.serialize(); + let mm_height_bytes = self.mm_height.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_SCREEN_SIZE_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + mm_width_bytes[0], + mm_width_bytes[1], + mm_width_bytes[2], + mm_width_bytes[3], + mm_height_bytes[0], + mm_height_bytes[1], + mm_height_bytes[2], + mm_height_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_screen_size(conn: &Conn, window: xproto::Window, width: u16, height: u16, mm_width: u32, mm_height: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let mm_width_bytes = mm_width.serialize(); - let mm_height_bytes = mm_height.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_SCREEN_SIZE_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - mm_width_bytes[0], - mm_width_bytes[1], - mm_width_bytes[2], - mm_width_bytes[3], - mm_height_bytes[0], - mm_height_bytes[1], - mm_height_bytes[2], - mm_height_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetScreenSizeRequest { + window, + width, + height, + mm_width, + mm_height, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1211,29 +1341,47 @@ impl Serialize for ModeInfo { /// Opcode for the GetScreenResources request pub const GET_SCREEN_RESOURCES_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetScreenResourcesRequest { + pub window: xproto::Window, +} +impl GetScreenResourcesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SCREEN_RESOURCES_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_screen_resources(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SCREEN_RESOURCES_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetScreenResourcesRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1398,34 +1546,54 @@ impl TryFrom for Connection { /// Opcode for the GetOutputInfo request pub const GET_OUTPUT_INFO_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetOutputInfoRequest { + pub output: Output, + pub config_timestamp: xproto::Timestamp, +} +impl GetOutputInfoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let output_bytes = self.output.serialize(); + let config_timestamp_bytes = self.config_timestamp.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_OUTPUT_INFO_REQUEST, + 0, + 0, + output_bytes[0], + output_bytes[1], + output_bytes[2], + output_bytes[3], + config_timestamp_bytes[0], + config_timestamp_bytes[1], + config_timestamp_bytes[2], + config_timestamp_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_output_info(conn: &Conn, output: Output, config_timestamp: xproto::Timestamp) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let output_bytes = output.serialize(); - let config_timestamp_bytes = config_timestamp.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_OUTPUT_INFO_REQUEST, - 0, - 0, - output_bytes[0], - output_bytes[1], - output_bytes[2], - output_bytes[3], - config_timestamp_bytes[0], - config_timestamp_bytes[1], - config_timestamp_bytes[2], - config_timestamp_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetOutputInfoRequest { + output, + config_timestamp, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1538,29 +1706,47 @@ impl GetOutputInfoReply { /// Opcode for the ListOutputProperties request pub const LIST_OUTPUT_PROPERTIES_REQUEST: u8 = 10; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListOutputPropertiesRequest { + pub output: Output, +} +impl ListOutputPropertiesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let output_bytes = self.output.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + LIST_OUTPUT_PROPERTIES_REQUEST, + 0, + 0, + output_bytes[0], + output_bytes[1], + output_bytes[2], + output_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_output_properties(conn: &Conn, output: Output) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let output_bytes = output.serialize(); - let mut request0 = [ - extension_information.major_opcode, - LIST_OUTPUT_PROPERTIES_REQUEST, - 0, - 0, - output_bytes[0], - output_bytes[1], - output_bytes[2], - output_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListOutputPropertiesRequest { + output, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1607,34 +1793,54 @@ impl ListOutputPropertiesReply { /// Opcode for the QueryOutputProperty request pub const QUERY_OUTPUT_PROPERTY_REQUEST: u8 = 11; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryOutputPropertyRequest { + pub output: Output, + pub property: xproto::Atom, +} +impl QueryOutputPropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let output_bytes = self.output.serialize(); + let property_bytes = self.property.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_OUTPUT_PROPERTY_REQUEST, + 0, + 0, + output_bytes[0], + output_bytes[1], + output_bytes[2], + output_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_output_property(conn: &Conn, output: Output, property: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let output_bytes = output.serialize(); - let property_bytes = property.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_OUTPUT_PROPERTY_REQUEST, - 0, - 0, - output_bytes[0], - output_bytes[1], - output_bytes[2], - output_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryOutputPropertyRequest { + output, + property, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1685,183 +1891,289 @@ impl QueryOutputPropertyReply { /// Opcode for the ConfigureOutputProperty request pub const CONFIGURE_OUTPUT_PROPERTY_REQUEST: u8 = 12; -pub fn configure_output_property<'c, Conn>(conn: &'c Conn, output: Output, property: xproto::Atom, pending: bool, range: bool, values: &[i32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ConfigureOutputPropertyRequest<'input> { + pub output: Output, + pub property: xproto::Atom, + pub pending: bool, + pub range: bool, + pub values: &'input [i32], +} +impl<'input> ConfigureOutputPropertyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let output_bytes = self.output.serialize(); + let property_bytes = self.property.serialize(); + let pending_bytes = self.pending.serialize(); + let range_bytes = self.range.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CONFIGURE_OUTPUT_PROPERTY_REQUEST, + 0, + 0, + output_bytes[0], + output_bytes[1], + output_bytes[2], + output_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + pending_bytes[0], + range_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let values_bytes = self.values.serialize(); + let length_so_far = length_so_far + values_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), values_bytes.into(), padding0.into()], vec![])) + } +} +pub fn configure_output_property<'c, 'input, Conn>(conn: &'c Conn, output: Output, property: xproto::Atom, pending: bool, range: bool, values: &'input [i32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let output_bytes = output.serialize(); - let property_bytes = property.serialize(); - let pending_bytes = pending.serialize(); - let range_bytes = range.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CONFIGURE_OUTPUT_PROPERTY_REQUEST, - 0, - 0, - output_bytes[0], - output_bytes[1], - output_bytes[2], - output_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - pending_bytes[0], - range_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let values_bytes = values.serialize(); - let length_so_far = length_so_far + values_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&values_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ConfigureOutputPropertyRequest { + output, + property, + pending, + range, + values, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ChangeOutputProperty request pub const CHANGE_OUTPUT_PROPERTY_REQUEST: u8 = 13; -pub fn change_output_property<'c, Conn>(conn: &'c Conn, output: Output, property: xproto::Atom, type_: xproto::Atom, format: u8, mode: xproto::PropMode, num_units: u32, data: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeOutputPropertyRequest<'input> { + pub output: Output, + pub property: xproto::Atom, + pub type_: xproto::Atom, + pub format: u8, + pub mode: xproto::PropMode, + pub num_units: u32, + pub data: &'input [u8], +} +impl<'input> ChangeOutputPropertyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let output_bytes = self.output.serialize(); + let property_bytes = self.property.serialize(); + let type_bytes = self.type_.serialize(); + let format_bytes = self.format.serialize(); + let mode_bytes = u8::from(self.mode).serialize(); + let num_units_bytes = self.num_units.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_OUTPUT_PROPERTY_REQUEST, + 0, + 0, + output_bytes[0], + output_bytes[1], + output_bytes[2], + output_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + format_bytes[0], + mode_bytes[0], + 0, + 0, + num_units_bytes[0], + num_units_bytes[1], + num_units_bytes[2], + num_units_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(self.data.len(), usize::try_from(self.num_units.checked_mul(u32::from(self.format)).unwrap().checked_div(8u32).unwrap()).unwrap(), "`data` has an incorrect length"); + let length_so_far = length_so_far + (&self.data[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.data[..]).into(), padding0.into()], vec![])) + } +} +pub fn change_output_property<'c, 'input, Conn>(conn: &'c Conn, output: Output, property: xproto::Atom, type_: xproto::Atom, format: u8, mode: xproto::PropMode, num_units: u32, data: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let output_bytes = output.serialize(); - let property_bytes = property.serialize(); - let type_bytes = type_.serialize(); - let format_bytes = format.serialize(); - let mode_bytes = u8::from(mode).serialize(); - let num_units_bytes = num_units.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_OUTPUT_PROPERTY_REQUEST, - 0, - 0, - output_bytes[0], - output_bytes[1], - output_bytes[2], - output_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - format_bytes[0], - mode_bytes[0], - 0, - 0, - num_units_bytes[0], - num_units_bytes[1], - num_units_bytes[2], - num_units_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(data.len(), usize::try_from(num_units.checked_mul(u32::from(format)).unwrap().checked_div(8u32).unwrap()).unwrap(), "`data` has an incorrect length"); - let length_so_far = length_so_far + data.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(data), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeOutputPropertyRequest { + output, + property, + type_, + format, + mode, + num_units, + data, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeleteOutputProperty request pub const DELETE_OUTPUT_PROPERTY_REQUEST: u8 = 14; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DeleteOutputPropertyRequest { + pub output: Output, + pub property: xproto::Atom, +} +impl DeleteOutputPropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let output_bytes = self.output.serialize(); + let property_bytes = self.property.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_OUTPUT_PROPERTY_REQUEST, + 0, + 0, + output_bytes[0], + output_bytes[1], + output_bytes[2], + output_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn delete_output_property(conn: &Conn, output: Output, property: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let output_bytes = output.serialize(); - let property_bytes = property.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_OUTPUT_PROPERTY_REQUEST, - 0, - 0, - output_bytes[0], - output_bytes[1], - output_bytes[2], - output_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DeleteOutputPropertyRequest { + output, + property, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetOutputProperty request pub const GET_OUTPUT_PROPERTY_REQUEST: u8 = 15; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetOutputPropertyRequest { + pub output: Output, + pub property: xproto::Atom, + pub type_: xproto::Atom, + pub long_offset: u32, + pub long_length: u32, + pub delete: bool, + pub pending: bool, +} +impl GetOutputPropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let output_bytes = self.output.serialize(); + let property_bytes = self.property.serialize(); + let type_bytes = self.type_.serialize(); + let long_offset_bytes = self.long_offset.serialize(); + let long_length_bytes = self.long_length.serialize(); + let delete_bytes = self.delete.serialize(); + let pending_bytes = self.pending.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_OUTPUT_PROPERTY_REQUEST, + 0, + 0, + output_bytes[0], + output_bytes[1], + output_bytes[2], + output_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + long_offset_bytes[0], + long_offset_bytes[1], + long_offset_bytes[2], + long_offset_bytes[3], + long_length_bytes[0], + long_length_bytes[1], + long_length_bytes[2], + long_length_bytes[3], + delete_bytes[0], + pending_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_output_property(conn: &Conn, output: Output, property: xproto::Atom, type_: A, long_offset: u32, long_length: u32, delete: bool, pending: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let type_: xproto::Atom = type_.into(); - let length_so_far = 0; - let output_bytes = output.serialize(); - let property_bytes = property.serialize(); - let type_bytes = type_.serialize(); - let long_offset_bytes = long_offset.serialize(); - let long_length_bytes = long_length.serialize(); - let delete_bytes = delete.serialize(); - let pending_bytes = pending.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_OUTPUT_PROPERTY_REQUEST, - 0, - 0, - output_bytes[0], - output_bytes[1], - output_bytes[2], - output_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - long_offset_bytes[0], - long_offset_bytes[1], - long_offset_bytes[2], - long_offset_bytes[3], - long_length_bytes[0], - long_length_bytes[1], - long_length_bytes[2], - long_length_bytes[3], - delete_bytes[0], - pending_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetOutputPropertyRequest { + output, + property, + type_, + long_offset, + long_length, + delete, + pending, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1900,65 +2212,87 @@ impl TryFrom<&[u8]> for GetOutputPropertyReply { /// Opcode for the CreateMode request pub const CREATE_MODE_REQUEST: u8 = 16; -pub fn create_mode<'c, Conn>(conn: &'c Conn, window: xproto::Window, mode_info: ModeInfo, name: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateModeRequest<'input> { + pub window: xproto::Window, + pub mode_info: ModeInfo, + pub name: &'input [u8], +} +impl<'input> CreateModeRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mode_info_bytes = self.mode_info.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_MODE_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + mode_info_bytes[0], + mode_info_bytes[1], + mode_info_bytes[2], + mode_info_bytes[3], + mode_info_bytes[4], + mode_info_bytes[5], + mode_info_bytes[6], + mode_info_bytes[7], + mode_info_bytes[8], + mode_info_bytes[9], + mode_info_bytes[10], + mode_info_bytes[11], + mode_info_bytes[12], + mode_info_bytes[13], + mode_info_bytes[14], + mode_info_bytes[15], + mode_info_bytes[16], + mode_info_bytes[17], + mode_info_bytes[18], + mode_info_bytes[19], + mode_info_bytes[20], + mode_info_bytes[21], + mode_info_bytes[22], + mode_info_bytes[23], + mode_info_bytes[24], + mode_info_bytes[25], + mode_info_bytes[26], + mode_info_bytes[27], + mode_info_bytes[28], + mode_info_bytes[29], + mode_info_bytes[30], + mode_info_bytes[31], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) + } +} +pub fn create_mode<'c, 'input, Conn>(conn: &'c Conn, window: xproto::Window, mode_info: ModeInfo, name: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mode_info_bytes = mode_info.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_MODE_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - mode_info_bytes[0], - mode_info_bytes[1], - mode_info_bytes[2], - mode_info_bytes[3], - mode_info_bytes[4], - mode_info_bytes[5], - mode_info_bytes[6], - mode_info_bytes[7], - mode_info_bytes[8], - mode_info_bytes[9], - mode_info_bytes[10], - mode_info_bytes[11], - mode_info_bytes[12], - mode_info_bytes[13], - mode_info_bytes[14], - mode_info_bytes[15], - mode_info_bytes[16], - mode_info_bytes[17], - mode_info_bytes[18], - mode_info_bytes[19], - mode_info_bytes[20], - mode_info_bytes[21], - mode_info_bytes[22], - mode_info_bytes[23], - mode_info_bytes[24], - mode_info_bytes[25], - mode_info_bytes[26], - mode_info_bytes[27], - mode_info_bytes[28], - mode_info_bytes[29], - mode_info_bytes[30], - mode_info_bytes[31], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateModeRequest { + window, + mode_info, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1989,125 +2323,203 @@ impl TryFrom<&[u8]> for CreateModeReply { /// Opcode for the DestroyMode request pub const DESTROY_MODE_REQUEST: u8 = 17; -pub fn destroy_mode(conn: &Conn, mode: Mode) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, -{ - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mode_bytes = mode.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_MODE_REQUEST, - 0, - 0, - mode_bytes[0], - mode_bytes[1], - mode_bytes[2], - mode_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyModeRequest { + pub mode: Mode, } - +impl DestroyModeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mode_bytes = self.mode.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_MODE_REQUEST, + 0, + 0, + mode_bytes[0], + mode_bytes[1], + mode_bytes[2], + mode_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +pub fn destroy_mode(conn: &Conn, mode: Mode) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, +{ + let request0 = DestroyModeRequest { + mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) +} + /// Opcode for the AddOutputMode request pub const ADD_OUTPUT_MODE_REQUEST: u8 = 18; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AddOutputModeRequest { + pub output: Output, + pub mode: Mode, +} +impl AddOutputModeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let output_bytes = self.output.serialize(); + let mode_bytes = self.mode.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + ADD_OUTPUT_MODE_REQUEST, + 0, + 0, + output_bytes[0], + output_bytes[1], + output_bytes[2], + output_bytes[3], + mode_bytes[0], + mode_bytes[1], + mode_bytes[2], + mode_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn add_output_mode(conn: &Conn, output: Output, mode: Mode) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let output_bytes = output.serialize(); - let mode_bytes = mode.serialize(); - let mut request0 = [ - extension_information.major_opcode, - ADD_OUTPUT_MODE_REQUEST, - 0, - 0, - output_bytes[0], - output_bytes[1], - output_bytes[2], - output_bytes[3], - mode_bytes[0], - mode_bytes[1], - mode_bytes[2], - mode_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = AddOutputModeRequest { + output, + mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeleteOutputMode request pub const DELETE_OUTPUT_MODE_REQUEST: u8 = 19; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DeleteOutputModeRequest { + pub output: Output, + pub mode: Mode, +} +impl DeleteOutputModeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let output_bytes = self.output.serialize(); + let mode_bytes = self.mode.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_OUTPUT_MODE_REQUEST, + 0, + 0, + output_bytes[0], + output_bytes[1], + output_bytes[2], + output_bytes[3], + mode_bytes[0], + mode_bytes[1], + mode_bytes[2], + mode_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn delete_output_mode(conn: &Conn, output: Output, mode: Mode) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let output_bytes = output.serialize(); - let mode_bytes = mode.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_OUTPUT_MODE_REQUEST, - 0, - 0, - output_bytes[0], - output_bytes[1], - output_bytes[2], - output_bytes[3], - mode_bytes[0], - mode_bytes[1], - mode_bytes[2], - mode_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DeleteOutputModeRequest { + output, + mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetCrtcInfo request pub const GET_CRTC_INFO_REQUEST: u8 = 20; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetCrtcInfoRequest { + pub crtc: Crtc, + pub config_timestamp: xproto::Timestamp, +} +impl GetCrtcInfoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let crtc_bytes = self.crtc.serialize(); + let config_timestamp_bytes = self.config_timestamp.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CRTC_INFO_REQUEST, + 0, + 0, + crtc_bytes[0], + crtc_bytes[1], + crtc_bytes[2], + crtc_bytes[3], + config_timestamp_bytes[0], + config_timestamp_bytes[1], + config_timestamp_bytes[2], + config_timestamp_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_crtc_info(conn: &Conn, crtc: Crtc, config_timestamp: xproto::Timestamp) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let crtc_bytes = crtc.serialize(); - let config_timestamp_bytes = config_timestamp.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CRTC_INFO_REQUEST, - 0, - 0, - crtc_bytes[0], - crtc_bytes[1], - crtc_bytes[2], - crtc_bytes[3], - config_timestamp_bytes[0], - config_timestamp_bytes[1], - config_timestamp_bytes[2], - config_timestamp_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetCrtcInfoRequest { + crtc, + config_timestamp, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2187,61 +2599,93 @@ impl GetCrtcInfoReply { /// Opcode for the SetCrtcConfig request pub const SET_CRTC_CONFIG_REQUEST: u8 = 21; -pub fn set_crtc_config<'c, Conn, A>(conn: &'c Conn, crtc: Crtc, timestamp: xproto::Timestamp, config_timestamp: xproto::Timestamp, x: i16, y: i16, mode: Mode, rotation: A, outputs: &[Output]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetCrtcConfigRequest<'input> { + pub crtc: Crtc, + pub timestamp: xproto::Timestamp, + pub config_timestamp: xproto::Timestamp, + pub x: i16, + pub y: i16, + pub mode: Mode, + pub rotation: u16, + pub outputs: &'input [Output], +} +impl<'input> SetCrtcConfigRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let crtc_bytes = self.crtc.serialize(); + let timestamp_bytes = self.timestamp.serialize(); + let config_timestamp_bytes = self.config_timestamp.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let mode_bytes = self.mode.serialize(); + let rotation_bytes = self.rotation.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_CRTC_CONFIG_REQUEST, + 0, + 0, + crtc_bytes[0], + crtc_bytes[1], + crtc_bytes[2], + crtc_bytes[3], + timestamp_bytes[0], + timestamp_bytes[1], + timestamp_bytes[2], + timestamp_bytes[3], + config_timestamp_bytes[0], + config_timestamp_bytes[1], + config_timestamp_bytes[2], + config_timestamp_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + mode_bytes[0], + mode_bytes[1], + mode_bytes[2], + mode_bytes[3], + rotation_bytes[0], + rotation_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let outputs_bytes = self.outputs.serialize(); + let length_so_far = length_so_far + outputs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), outputs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_crtc_config<'c, 'input, Conn, A>(conn: &'c Conn, crtc: Crtc, timestamp: xproto::Timestamp, config_timestamp: xproto::Timestamp, x: i16, y: i16, mode: Mode, rotation: A, outputs: &'input [Output]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let rotation: u16 = rotation.into(); - let length_so_far = 0; - let crtc_bytes = crtc.serialize(); - let timestamp_bytes = timestamp.serialize(); - let config_timestamp_bytes = config_timestamp.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let mode_bytes = mode.serialize(); - let rotation_bytes = rotation.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_CRTC_CONFIG_REQUEST, - 0, - 0, - crtc_bytes[0], - crtc_bytes[1], - crtc_bytes[2], - crtc_bytes[3], - timestamp_bytes[0], - timestamp_bytes[1], - timestamp_bytes[2], - timestamp_bytes[3], - config_timestamp_bytes[0], - config_timestamp_bytes[1], - config_timestamp_bytes[2], - config_timestamp_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - mode_bytes[0], - mode_bytes[1], - mode_bytes[2], - mode_bytes[3], - rotation_bytes[0], - rotation_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let outputs_bytes = outputs.serialize(); - let length_so_far = length_so_far + outputs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&outputs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetCrtcConfigRequest { + crtc, + timestamp, + config_timestamp, + x, + y, + mode, + rotation, + outputs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -2274,29 +2718,47 @@ impl TryFrom<&[u8]> for SetCrtcConfigReply { /// Opcode for the GetCrtcGammaSize request pub const GET_CRTC_GAMMA_SIZE_REQUEST: u8 = 22; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetCrtcGammaSizeRequest { + pub crtc: Crtc, +} +impl GetCrtcGammaSizeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let crtc_bytes = self.crtc.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CRTC_GAMMA_SIZE_REQUEST, + 0, + 0, + crtc_bytes[0], + crtc_bytes[1], + crtc_bytes[2], + crtc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_crtc_gamma_size(conn: &Conn, crtc: Crtc) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let crtc_bytes = crtc.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CRTC_GAMMA_SIZE_REQUEST, - 0, - 0, - crtc_bytes[0], - crtc_bytes[1], - crtc_bytes[2], - crtc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetCrtcGammaSizeRequest { + crtc, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -2327,29 +2789,47 @@ impl TryFrom<&[u8]> for GetCrtcGammaSizeReply { /// Opcode for the GetCrtcGamma request pub const GET_CRTC_GAMMA_REQUEST: u8 = 23; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetCrtcGammaRequest { + pub crtc: Crtc, +} +impl GetCrtcGammaRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let crtc_bytes = self.crtc.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CRTC_GAMMA_REQUEST, + 0, + 0, + crtc_bytes[0], + crtc_bytes[1], + crtc_bytes[2], + crtc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_crtc_gamma(conn: &Conn, crtc: Crtc) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let crtc_bytes = crtc.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CRTC_GAMMA_REQUEST, - 0, - 0, - crtc_bytes[0], - crtc_bytes[1], - crtc_bytes[2], - crtc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetCrtcGammaRequest { + crtc, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2400,72 +2880,114 @@ impl GetCrtcGammaReply { /// Opcode for the SetCrtcGamma request pub const SET_CRTC_GAMMA_REQUEST: u8 = 24; -pub fn set_crtc_gamma<'c, Conn>(conn: &'c Conn, crtc: Crtc, red: &[u16], green: &[u16], blue: &[u16]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetCrtcGammaRequest<'input> { + pub crtc: Crtc, + pub red: &'input [u16], + pub green: &'input [u16], + pub blue: &'input [u16], +} +impl<'input> SetCrtcGammaRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let crtc_bytes = self.crtc.serialize(); + let size = u16::try_from(self.red.len()).expect("`red` has too many elements"); + let size_bytes = size.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_CRTC_GAMMA_REQUEST, + 0, + 0, + crtc_bytes[0], + crtc_bytes[1], + crtc_bytes[2], + crtc_bytes[3], + size_bytes[0], + size_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let red_bytes = self.red.serialize(); + let length_so_far = length_so_far + red_bytes.len(); + assert_eq!(self.green.len(), usize::try_from(size).unwrap(), "`green` has an incorrect length"); + let green_bytes = self.green.serialize(); + let length_so_far = length_so_far + green_bytes.len(); + assert_eq!(self.blue.len(), usize::try_from(size).unwrap(), "`blue` has an incorrect length"); + let blue_bytes = self.blue.serialize(); + let length_so_far = length_so_far + blue_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), red_bytes.into(), green_bytes.into(), blue_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_crtc_gamma<'c, 'input, Conn>(conn: &'c Conn, crtc: Crtc, red: &'input [u16], green: &'input [u16], blue: &'input [u16]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let crtc_bytes = crtc.serialize(); - let size = u16::try_from(red.len()).expect("`red` has too many elements"); - let size_bytes = size.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_CRTC_GAMMA_REQUEST, - 0, - 0, - crtc_bytes[0], - crtc_bytes[1], - crtc_bytes[2], - crtc_bytes[3], - size_bytes[0], - size_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let red_bytes = red.serialize(); - let length_so_far = length_so_far + red_bytes.len(); - assert_eq!(green.len(), usize::try_from(size).unwrap(), "`green` has an incorrect length"); - let green_bytes = green.serialize(); - let length_so_far = length_so_far + green_bytes.len(); - assert_eq!(blue.len(), usize::try_from(size).unwrap(), "`blue` has an incorrect length"); - let blue_bytes = blue.serialize(); - let length_so_far = length_so_far + blue_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&red_bytes), IoSlice::new(&green_bytes), IoSlice::new(&blue_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetCrtcGammaRequest { + crtc, + red, + green, + blue, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetScreenResourcesCurrent request pub const GET_SCREEN_RESOURCES_CURRENT_REQUEST: u8 = 25; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetScreenResourcesCurrentRequest { + pub window: xproto::Window, +} +impl GetScreenResourcesCurrentRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SCREEN_RESOURCES_CURRENT_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_screen_resources_current(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SCREEN_RESOURCES_CURRENT_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetScreenResourcesCurrentRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2634,106 +3156,148 @@ bitmask_binop!(Transform, u8); /// Opcode for the SetCrtcTransform request pub const SET_CRTC_TRANSFORM_REQUEST: u8 = 26; -pub fn set_crtc_transform<'c, Conn>(conn: &'c Conn, crtc: Crtc, transform: render::Transform, filter_name: &[u8], filter_params: &[render::Fixed]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetCrtcTransformRequest<'input> { + pub crtc: Crtc, + pub transform: render::Transform, + pub filter_name: &'input [u8], + pub filter_params: &'input [render::Fixed], +} +impl<'input> SetCrtcTransformRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let crtc_bytes = self.crtc.serialize(); + let transform_bytes = self.transform.serialize(); + let filter_len = u16::try_from(self.filter_name.len()).expect("`filter_name` has too many elements"); + let filter_len_bytes = filter_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_CRTC_TRANSFORM_REQUEST, + 0, + 0, + crtc_bytes[0], + crtc_bytes[1], + crtc_bytes[2], + crtc_bytes[3], + transform_bytes[0], + transform_bytes[1], + transform_bytes[2], + transform_bytes[3], + transform_bytes[4], + transform_bytes[5], + transform_bytes[6], + transform_bytes[7], + transform_bytes[8], + transform_bytes[9], + transform_bytes[10], + transform_bytes[11], + transform_bytes[12], + transform_bytes[13], + transform_bytes[14], + transform_bytes[15], + transform_bytes[16], + transform_bytes[17], + transform_bytes[18], + transform_bytes[19], + transform_bytes[20], + transform_bytes[21], + transform_bytes[22], + transform_bytes[23], + transform_bytes[24], + transform_bytes[25], + transform_bytes[26], + transform_bytes[27], + transform_bytes[28], + transform_bytes[29], + transform_bytes[30], + transform_bytes[31], + transform_bytes[32], + transform_bytes[33], + transform_bytes[34], + transform_bytes[35], + filter_len_bytes[0], + filter_len_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.filter_name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + let filter_params_bytes = self.filter_params.serialize(); + let length_so_far = length_so_far + filter_params_bytes.len(); + let padding1 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding1.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.filter_name[..]).into(), padding0.into(), filter_params_bytes.into(), padding1.into()], vec![])) + } +} +pub fn set_crtc_transform<'c, 'input, Conn>(conn: &'c Conn, crtc: Crtc, transform: render::Transform, filter_name: &'input [u8], filter_params: &'input [render::Fixed]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let crtc_bytes = crtc.serialize(); - let transform_bytes = transform.serialize(); - let filter_len = u16::try_from(filter_name.len()).expect("`filter_name` has too many elements"); - let filter_len_bytes = filter_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_CRTC_TRANSFORM_REQUEST, - 0, - 0, - crtc_bytes[0], - crtc_bytes[1], - crtc_bytes[2], - crtc_bytes[3], - transform_bytes[0], - transform_bytes[1], - transform_bytes[2], - transform_bytes[3], - transform_bytes[4], - transform_bytes[5], - transform_bytes[6], - transform_bytes[7], - transform_bytes[8], - transform_bytes[9], - transform_bytes[10], - transform_bytes[11], - transform_bytes[12], - transform_bytes[13], - transform_bytes[14], - transform_bytes[15], - transform_bytes[16], - transform_bytes[17], - transform_bytes[18], - transform_bytes[19], - transform_bytes[20], - transform_bytes[21], - transform_bytes[22], - transform_bytes[23], - transform_bytes[24], - transform_bytes[25], - transform_bytes[26], - transform_bytes[27], - transform_bytes[28], - transform_bytes[29], - transform_bytes[30], - transform_bytes[31], - transform_bytes[32], - transform_bytes[33], - transform_bytes[34], - transform_bytes[35], - filter_len_bytes[0], - filter_len_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + filter_name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - let filter_params_bytes = filter_params.serialize(); - let length_so_far = length_so_far + filter_params_bytes.len(); - let padding1 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding1.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(filter_name), IoSlice::new(&padding0), IoSlice::new(&filter_params_bytes), IoSlice::new(&padding1)], vec![])?) + let request0 = SetCrtcTransformRequest { + crtc, + transform, + filter_name, + filter_params, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetCrtcTransform request pub const GET_CRTC_TRANSFORM_REQUEST: u8 = 27; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetCrtcTransformRequest { + pub crtc: Crtc, +} +impl GetCrtcTransformRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let crtc_bytes = self.crtc.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CRTC_TRANSFORM_REQUEST, + 0, + 0, + crtc_bytes[0], + crtc_bytes[1], + crtc_bytes[2], + crtc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_crtc_transform(conn: &Conn, crtc: Crtc) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let crtc_bytes = crtc.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CRTC_TRANSFORM_REQUEST, - 0, - 0, - crtc_bytes[0], - crtc_bytes[1], - crtc_bytes[2], - crtc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetCrtcTransformRequest { + crtc, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2846,29 +3410,47 @@ impl GetCrtcTransformReply { /// Opcode for the GetPanning request pub const GET_PANNING_REQUEST: u8 = 28; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPanningRequest { + pub crtc: Crtc, +} +impl GetPanningRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let crtc_bytes = self.crtc.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PANNING_REQUEST, + 0, + 0, + crtc_bytes[0], + crtc_bytes[1], + crtc_bytes[2], + crtc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_panning(conn: &Conn, crtc: Crtc) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let crtc_bytes = crtc.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PANNING_REQUEST, - 0, - 0, - crtc_bytes[0], - crtc_bytes[1], - crtc_bytes[2], - crtc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPanningRequest { + crtc, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -2924,70 +3506,114 @@ impl TryFrom<&[u8]> for GetPanningReply { /// Opcode for the SetPanning request pub const SET_PANNING_REQUEST: u8 = 29; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetPanningRequest { + pub crtc: Crtc, + pub timestamp: xproto::Timestamp, + pub left: u16, + pub top: u16, + pub width: u16, + pub height: u16, + pub track_left: u16, + pub track_top: u16, + pub track_width: u16, + pub track_height: u16, + pub border_left: i16, + pub border_top: i16, + pub border_right: i16, + pub border_bottom: i16, +} +impl SetPanningRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let crtc_bytes = self.crtc.serialize(); + let timestamp_bytes = self.timestamp.serialize(); + let left_bytes = self.left.serialize(); + let top_bytes = self.top.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let track_left_bytes = self.track_left.serialize(); + let track_top_bytes = self.track_top.serialize(); + let track_width_bytes = self.track_width.serialize(); + let track_height_bytes = self.track_height.serialize(); + let border_left_bytes = self.border_left.serialize(); + let border_top_bytes = self.border_top.serialize(); + let border_right_bytes = self.border_right.serialize(); + let border_bottom_bytes = self.border_bottom.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PANNING_REQUEST, + 0, + 0, + crtc_bytes[0], + crtc_bytes[1], + crtc_bytes[2], + crtc_bytes[3], + timestamp_bytes[0], + timestamp_bytes[1], + timestamp_bytes[2], + timestamp_bytes[3], + left_bytes[0], + left_bytes[1], + top_bytes[0], + top_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + track_left_bytes[0], + track_left_bytes[1], + track_top_bytes[0], + track_top_bytes[1], + track_width_bytes[0], + track_width_bytes[1], + track_height_bytes[0], + track_height_bytes[1], + border_left_bytes[0], + border_left_bytes[1], + border_top_bytes[0], + border_top_bytes[1], + border_right_bytes[0], + border_right_bytes[1], + border_bottom_bytes[0], + border_bottom_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_panning(conn: &Conn, crtc: Crtc, timestamp: xproto::Timestamp, left: u16, top: u16, width: u16, height: u16, track_left: u16, track_top: u16, track_width: u16, track_height: u16, border_left: i16, border_top: i16, border_right: i16, border_bottom: i16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let crtc_bytes = crtc.serialize(); - let timestamp_bytes = timestamp.serialize(); - let left_bytes = left.serialize(); - let top_bytes = top.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let track_left_bytes = track_left.serialize(); - let track_top_bytes = track_top.serialize(); - let track_width_bytes = track_width.serialize(); - let track_height_bytes = track_height.serialize(); - let border_left_bytes = border_left.serialize(); - let border_top_bytes = border_top.serialize(); - let border_right_bytes = border_right.serialize(); - let border_bottom_bytes = border_bottom.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PANNING_REQUEST, - 0, - 0, - crtc_bytes[0], - crtc_bytes[1], - crtc_bytes[2], - crtc_bytes[3], - timestamp_bytes[0], - timestamp_bytes[1], - timestamp_bytes[2], - timestamp_bytes[3], - left_bytes[0], - left_bytes[1], - top_bytes[0], - top_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - track_left_bytes[0], - track_left_bytes[1], - track_top_bytes[0], - track_top_bytes[1], - track_width_bytes[0], - track_width_bytes[1], - track_height_bytes[0], - track_height_bytes[1], - border_left_bytes[0], - border_left_bytes[1], - border_top_bytes[0], - border_top_bytes[1], - border_right_bytes[0], - border_right_bytes[1], - border_bottom_bytes[0], - border_bottom_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetPanningRequest { + crtc, + timestamp, + left, + top, + width, + height, + track_left, + track_top, + track_width, + track_height, + border_left, + border_top, + border_right, + border_bottom, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -3016,64 +3642,102 @@ impl TryFrom<&[u8]> for SetPanningReply { Ok(Self::try_parse(value)?.0) } } - -/// Opcode for the SetOutputPrimary request -pub const SET_OUTPUT_PRIMARY_REQUEST: u8 = 30; + +/// Opcode for the SetOutputPrimary request +pub const SET_OUTPUT_PRIMARY_REQUEST: u8 = 30; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetOutputPrimaryRequest { + pub window: xproto::Window, + pub output: Output, +} +impl SetOutputPrimaryRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let output_bytes = self.output.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_OUTPUT_PRIMARY_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + output_bytes[0], + output_bytes[1], + output_bytes[2], + output_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_output_primary(conn: &Conn, window: xproto::Window, output: Output) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let output_bytes = output.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_OUTPUT_PRIMARY_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - output_bytes[0], - output_bytes[1], - output_bytes[2], - output_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetOutputPrimaryRequest { + window, + output, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetOutputPrimary request pub const GET_OUTPUT_PRIMARY_REQUEST: u8 = 31; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetOutputPrimaryRequest { + pub window: xproto::Window, +} +impl GetOutputPrimaryRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_OUTPUT_PRIMARY_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_output_primary(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_OUTPUT_PRIMARY_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetOutputPrimaryRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -3103,29 +3767,47 @@ impl TryFrom<&[u8]> for GetOutputPrimaryReply { /// Opcode for the GetProviders request pub const GET_PROVIDERS_REQUEST: u8 = 32; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetProvidersRequest { + pub window: xproto::Window, +} +impl GetProvidersRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PROVIDERS_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_providers(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PROVIDERS_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetProvidersRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -3243,34 +3925,54 @@ bitmask_binop!(ProviderCapability, u8); /// Opcode for the GetProviderInfo request pub const GET_PROVIDER_INFO_REQUEST: u8 = 33; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetProviderInfoRequest { + pub provider: Provider, + pub config_timestamp: xproto::Timestamp, +} +impl GetProviderInfoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let provider_bytes = self.provider.serialize(); + let config_timestamp_bytes = self.config_timestamp.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PROVIDER_INFO_REQUEST, + 0, + 0, + provider_bytes[0], + provider_bytes[1], + provider_bytes[2], + provider_bytes[3], + config_timestamp_bytes[0], + config_timestamp_bytes[1], + config_timestamp_bytes[2], + config_timestamp_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_provider_info(conn: &Conn, provider: Provider, config_timestamp: xproto::Timestamp) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let provider_bytes = provider.serialize(); - let config_timestamp_bytes = config_timestamp.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PROVIDER_INFO_REQUEST, - 0, - 0, - provider_bytes[0], - provider_bytes[1], - provider_bytes[2], - provider_bytes[3], - config_timestamp_bytes[0], - config_timestamp_bytes[1], - config_timestamp_bytes[2], - config_timestamp_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetProviderInfoRequest { + provider, + config_timestamp, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -3373,103 +4075,165 @@ impl GetProviderInfoReply { /// Opcode for the SetProviderOffloadSink request pub const SET_PROVIDER_OFFLOAD_SINK_REQUEST: u8 = 34; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetProviderOffloadSinkRequest { + pub provider: Provider, + pub sink_provider: Provider, + pub config_timestamp: xproto::Timestamp, +} +impl SetProviderOffloadSinkRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let provider_bytes = self.provider.serialize(); + let sink_provider_bytes = self.sink_provider.serialize(); + let config_timestamp_bytes = self.config_timestamp.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PROVIDER_OFFLOAD_SINK_REQUEST, + 0, + 0, + provider_bytes[0], + provider_bytes[1], + provider_bytes[2], + provider_bytes[3], + sink_provider_bytes[0], + sink_provider_bytes[1], + sink_provider_bytes[2], + sink_provider_bytes[3], + config_timestamp_bytes[0], + config_timestamp_bytes[1], + config_timestamp_bytes[2], + config_timestamp_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_provider_offload_sink(conn: &Conn, provider: Provider, sink_provider: Provider, config_timestamp: xproto::Timestamp) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let provider_bytes = provider.serialize(); - let sink_provider_bytes = sink_provider.serialize(); - let config_timestamp_bytes = config_timestamp.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PROVIDER_OFFLOAD_SINK_REQUEST, - 0, - 0, - provider_bytes[0], - provider_bytes[1], - provider_bytes[2], - provider_bytes[3], - sink_provider_bytes[0], - sink_provider_bytes[1], - sink_provider_bytes[2], - sink_provider_bytes[3], - config_timestamp_bytes[0], - config_timestamp_bytes[1], - config_timestamp_bytes[2], - config_timestamp_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetProviderOffloadSinkRequest { + provider, + sink_provider, + config_timestamp, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetProviderOutputSource request pub const SET_PROVIDER_OUTPUT_SOURCE_REQUEST: u8 = 35; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetProviderOutputSourceRequest { + pub provider: Provider, + pub source_provider: Provider, + pub config_timestamp: xproto::Timestamp, +} +impl SetProviderOutputSourceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let provider_bytes = self.provider.serialize(); + let source_provider_bytes = self.source_provider.serialize(); + let config_timestamp_bytes = self.config_timestamp.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PROVIDER_OUTPUT_SOURCE_REQUEST, + 0, + 0, + provider_bytes[0], + provider_bytes[1], + provider_bytes[2], + provider_bytes[3], + source_provider_bytes[0], + source_provider_bytes[1], + source_provider_bytes[2], + source_provider_bytes[3], + config_timestamp_bytes[0], + config_timestamp_bytes[1], + config_timestamp_bytes[2], + config_timestamp_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_provider_output_source(conn: &Conn, provider: Provider, source_provider: Provider, config_timestamp: xproto::Timestamp) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let provider_bytes = provider.serialize(); - let source_provider_bytes = source_provider.serialize(); - let config_timestamp_bytes = config_timestamp.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PROVIDER_OUTPUT_SOURCE_REQUEST, - 0, - 0, - provider_bytes[0], - provider_bytes[1], - provider_bytes[2], - provider_bytes[3], - source_provider_bytes[0], - source_provider_bytes[1], - source_provider_bytes[2], - source_provider_bytes[3], - config_timestamp_bytes[0], - config_timestamp_bytes[1], - config_timestamp_bytes[2], - config_timestamp_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetProviderOutputSourceRequest { + provider, + source_provider, + config_timestamp, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ListProviderProperties request pub const LIST_PROVIDER_PROPERTIES_REQUEST: u8 = 36; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListProviderPropertiesRequest { + pub provider: Provider, +} +impl ListProviderPropertiesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let provider_bytes = self.provider.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + LIST_PROVIDER_PROPERTIES_REQUEST, + 0, + 0, + provider_bytes[0], + provider_bytes[1], + provider_bytes[2], + provider_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_provider_properties(conn: &Conn, provider: Provider) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let provider_bytes = provider.serialize(); - let mut request0 = [ - extension_information.major_opcode, - LIST_PROVIDER_PROPERTIES_REQUEST, - 0, - 0, - provider_bytes[0], - provider_bytes[1], - provider_bytes[2], - provider_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListProviderPropertiesRequest { + provider, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -3516,34 +4280,54 @@ impl ListProviderPropertiesReply { /// Opcode for the QueryProviderProperty request pub const QUERY_PROVIDER_PROPERTY_REQUEST: u8 = 37; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryProviderPropertyRequest { + pub provider: Provider, + pub property: xproto::Atom, +} +impl QueryProviderPropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let provider_bytes = self.provider.serialize(); + let property_bytes = self.property.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_PROVIDER_PROPERTY_REQUEST, + 0, + 0, + provider_bytes[0], + provider_bytes[1], + provider_bytes[2], + provider_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_provider_property(conn: &Conn, provider: Provider, property: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let provider_bytes = provider.serialize(); - let property_bytes = property.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_PROVIDER_PROPERTY_REQUEST, - 0, - 0, - provider_bytes[0], - provider_bytes[1], - provider_bytes[2], - provider_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryProviderPropertyRequest { + provider, + property, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -3594,181 +4378,287 @@ impl QueryProviderPropertyReply { /// Opcode for the ConfigureProviderProperty request pub const CONFIGURE_PROVIDER_PROPERTY_REQUEST: u8 = 38; -pub fn configure_provider_property<'c, Conn>(conn: &'c Conn, provider: Provider, property: xproto::Atom, pending: bool, range: bool, values: &[i32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ConfigureProviderPropertyRequest<'input> { + pub provider: Provider, + pub property: xproto::Atom, + pub pending: bool, + pub range: bool, + pub values: &'input [i32], +} +impl<'input> ConfigureProviderPropertyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let provider_bytes = self.provider.serialize(); + let property_bytes = self.property.serialize(); + let pending_bytes = self.pending.serialize(); + let range_bytes = self.range.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CONFIGURE_PROVIDER_PROPERTY_REQUEST, + 0, + 0, + provider_bytes[0], + provider_bytes[1], + provider_bytes[2], + provider_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + pending_bytes[0], + range_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let values_bytes = self.values.serialize(); + let length_so_far = length_so_far + values_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), values_bytes.into(), padding0.into()], vec![])) + } +} +pub fn configure_provider_property<'c, 'input, Conn>(conn: &'c Conn, provider: Provider, property: xproto::Atom, pending: bool, range: bool, values: &'input [i32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let provider_bytes = provider.serialize(); - let property_bytes = property.serialize(); - let pending_bytes = pending.serialize(); - let range_bytes = range.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CONFIGURE_PROVIDER_PROPERTY_REQUEST, - 0, - 0, - provider_bytes[0], - provider_bytes[1], - provider_bytes[2], - provider_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - pending_bytes[0], - range_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let values_bytes = values.serialize(); - let length_so_far = length_so_far + values_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&values_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ConfigureProviderPropertyRequest { + provider, + property, + pending, + range, + values, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ChangeProviderProperty request pub const CHANGE_PROVIDER_PROPERTY_REQUEST: u8 = 39; -pub fn change_provider_property<'c, Conn>(conn: &'c Conn, provider: Provider, property: xproto::Atom, type_: xproto::Atom, format: u8, mode: u8, num_items: u32, data: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeProviderPropertyRequest<'input> { + pub provider: Provider, + pub property: xproto::Atom, + pub type_: xproto::Atom, + pub format: u8, + pub mode: u8, + pub num_items: u32, + pub data: &'input [u8], +} +impl<'input> ChangeProviderPropertyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let provider_bytes = self.provider.serialize(); + let property_bytes = self.property.serialize(); + let type_bytes = self.type_.serialize(); + let format_bytes = self.format.serialize(); + let mode_bytes = self.mode.serialize(); + let num_items_bytes = self.num_items.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_PROVIDER_PROPERTY_REQUEST, + 0, + 0, + provider_bytes[0], + provider_bytes[1], + provider_bytes[2], + provider_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + format_bytes[0], + mode_bytes[0], + 0, + 0, + num_items_bytes[0], + num_items_bytes[1], + num_items_bytes[2], + num_items_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(self.data.len(), usize::try_from(self.num_items.checked_mul(u32::from(self.format).checked_div(8u32).unwrap()).unwrap()).unwrap(), "`data` has an incorrect length"); + let length_so_far = length_so_far + (&self.data[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.data[..]).into(), padding0.into()], vec![])) + } +} +pub fn change_provider_property<'c, 'input, Conn>(conn: &'c Conn, provider: Provider, property: xproto::Atom, type_: xproto::Atom, format: u8, mode: u8, num_items: u32, data: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let provider_bytes = provider.serialize(); - let property_bytes = property.serialize(); - let type_bytes = type_.serialize(); - let format_bytes = format.serialize(); - let mode_bytes = mode.serialize(); - let num_items_bytes = num_items.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_PROVIDER_PROPERTY_REQUEST, - 0, - 0, - provider_bytes[0], - provider_bytes[1], - provider_bytes[2], - provider_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - format_bytes[0], - mode_bytes[0], - 0, - 0, - num_items_bytes[0], - num_items_bytes[1], - num_items_bytes[2], - num_items_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(data.len(), usize::try_from(num_items.checked_mul(u32::from(format).checked_div(8u32).unwrap()).unwrap()).unwrap(), "`data` has an incorrect length"); - let length_so_far = length_so_far + data.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(data), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeProviderPropertyRequest { + provider, + property, + type_, + format, + mode, + num_items, + data, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeleteProviderProperty request pub const DELETE_PROVIDER_PROPERTY_REQUEST: u8 = 40; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DeleteProviderPropertyRequest { + pub provider: Provider, + pub property: xproto::Atom, +} +impl DeleteProviderPropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let provider_bytes = self.provider.serialize(); + let property_bytes = self.property.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_PROVIDER_PROPERTY_REQUEST, + 0, + 0, + provider_bytes[0], + provider_bytes[1], + provider_bytes[2], + provider_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn delete_provider_property(conn: &Conn, provider: Provider, property: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let provider_bytes = provider.serialize(); - let property_bytes = property.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_PROVIDER_PROPERTY_REQUEST, - 0, - 0, - provider_bytes[0], - provider_bytes[1], - provider_bytes[2], - provider_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DeleteProviderPropertyRequest { + provider, + property, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetProviderProperty request pub const GET_PROVIDER_PROPERTY_REQUEST: u8 = 41; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetProviderPropertyRequest { + pub provider: Provider, + pub property: xproto::Atom, + pub type_: xproto::Atom, + pub long_offset: u32, + pub long_length: u32, + pub delete: bool, + pub pending: bool, +} +impl GetProviderPropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let provider_bytes = self.provider.serialize(); + let property_bytes = self.property.serialize(); + let type_bytes = self.type_.serialize(); + let long_offset_bytes = self.long_offset.serialize(); + let long_length_bytes = self.long_length.serialize(); + let delete_bytes = self.delete.serialize(); + let pending_bytes = self.pending.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PROVIDER_PROPERTY_REQUEST, + 0, + 0, + provider_bytes[0], + provider_bytes[1], + provider_bytes[2], + provider_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + long_offset_bytes[0], + long_offset_bytes[1], + long_offset_bytes[2], + long_offset_bytes[3], + long_length_bytes[0], + long_length_bytes[1], + long_length_bytes[2], + long_length_bytes[3], + delete_bytes[0], + pending_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_provider_property(conn: &Conn, provider: Provider, property: xproto::Atom, type_: xproto::Atom, long_offset: u32, long_length: u32, delete: bool, pending: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let provider_bytes = provider.serialize(); - let property_bytes = property.serialize(); - let type_bytes = type_.serialize(); - let long_offset_bytes = long_offset.serialize(); - let long_length_bytes = long_length.serialize(); - let delete_bytes = delete.serialize(); - let pending_bytes = pending.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PROVIDER_PROPERTY_REQUEST, - 0, - 0, - provider_bytes[0], - provider_bytes[1], - provider_bytes[2], - provider_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - long_offset_bytes[0], - long_offset_bytes[1], - long_offset_bytes[2], - long_offset_bytes[3], - long_length_bytes[0], - long_length_bytes[1], - long_length_bytes[2], - long_length_bytes[3], - delete_bytes[0], - pending_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetProviderPropertyRequest { + provider, + property, + type_, + long_offset, + long_length, + delete, + pending, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4529,34 +5419,54 @@ impl MonitorInfo { /// Opcode for the GetMonitors request pub const GET_MONITORS_REQUEST: u8 = 42; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMonitorsRequest { + pub window: xproto::Window, + pub get_active: bool, +} +impl GetMonitorsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let get_active_bytes = self.get_active.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MONITORS_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + get_active_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_monitors(conn: &Conn, window: xproto::Window, get_active: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let get_active_bytes = get_active.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MONITORS_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - get_active_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMonitorsRequest { + window, + get_active, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4607,111 +5517,175 @@ impl GetMonitorsReply { /// Opcode for the SetMonitor request pub const SET_MONITOR_REQUEST: u8 = 43; +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetMonitorRequest { + pub window: xproto::Window, + pub monitorinfo: MonitorInfo, +} +impl SetMonitorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_MONITOR_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let monitorinfo_bytes = self.monitorinfo.serialize(); + let length_so_far = length_so_far + monitorinfo_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), monitorinfo_bytes.into(), padding0.into()], vec![])) + } +} pub fn set_monitor(conn: &Conn, window: xproto::Window, monitorinfo: MonitorInfo) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_MONITOR_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let monitorinfo_bytes = monitorinfo.serialize(); - let length_so_far = length_so_far + monitorinfo_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&monitorinfo_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetMonitorRequest { + window, + monitorinfo, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeleteMonitor request pub const DELETE_MONITOR_REQUEST: u8 = 44; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DeleteMonitorRequest { + pub window: xproto::Window, + pub name: xproto::Atom, +} +impl DeleteMonitorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let name_bytes = self.name.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_MONITOR_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + name_bytes[0], + name_bytes[1], + name_bytes[2], + name_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn delete_monitor(conn: &Conn, window: xproto::Window, name: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let name_bytes = name.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_MONITOR_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - name_bytes[0], - name_bytes[1], - name_bytes[2], - name_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DeleteMonitorRequest { + window, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateLease request pub const CREATE_LEASE_REQUEST: u8 = 45; -pub fn create_lease<'c, Conn>(conn: &'c Conn, window: xproto::Window, lid: Lease, crtcs: &[Crtc], outputs: &[Output]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateLeaseRequest<'input> { + pub window: xproto::Window, + pub lid: Lease, + pub crtcs: &'input [Crtc], + pub outputs: &'input [Output], +} +impl<'input> CreateLeaseRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let lid_bytes = self.lid.serialize(); + let num_crtcs = u16::try_from(self.crtcs.len()).expect("`crtcs` has too many elements"); + let num_crtcs_bytes = num_crtcs.serialize(); + let num_outputs = u16::try_from(self.outputs.len()).expect("`outputs` has too many elements"); + let num_outputs_bytes = num_outputs.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_LEASE_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + lid_bytes[0], + lid_bytes[1], + lid_bytes[2], + lid_bytes[3], + num_crtcs_bytes[0], + num_crtcs_bytes[1], + num_outputs_bytes[0], + num_outputs_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let crtcs_bytes = self.crtcs.serialize(); + let length_so_far = length_so_far + crtcs_bytes.len(); + let outputs_bytes = self.outputs.serialize(); + let length_so_far = length_so_far + outputs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), crtcs_bytes.into(), outputs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_lease<'c, 'input, Conn>(conn: &'c Conn, window: xproto::Window, lid: Lease, crtcs: &'input [Crtc], outputs: &'input [Output]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let lid_bytes = lid.serialize(); - let num_crtcs = u16::try_from(crtcs.len()).expect("`crtcs` has too many elements"); - let num_crtcs_bytes = num_crtcs.serialize(); - let num_outputs = u16::try_from(outputs.len()).expect("`outputs` has too many elements"); - let num_outputs_bytes = num_outputs.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_LEASE_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - lid_bytes[0], - lid_bytes[1], - lid_bytes[2], - lid_bytes[3], - num_crtcs_bytes[0], - num_crtcs_bytes[1], - num_outputs_bytes[0], - num_outputs_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let crtcs_bytes = crtcs.serialize(); - let length_so_far = length_so_far + crtcs_bytes.len(); - let outputs_bytes = outputs.serialize(); - let length_so_far = length_so_far + outputs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply_with_fds(&[IoSlice::new(&request0), IoSlice::new(&crtcs_bytes), IoSlice::new(&outputs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateLeaseRequest { + window, + lid, + crtcs, + outputs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply_with_fds(&slices, fds)?) } #[derive(Debug, PartialEq, Eq)] @@ -4745,34 +5719,54 @@ impl TryFrom<(&[u8], Vec)> for CreateLeaseReply { /// Opcode for the FreeLease request pub const FREE_LEASE_REQUEST: u8 = 46; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FreeLeaseRequest { + pub lid: Lease, + pub terminate: u8, +} +impl FreeLeaseRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let lid_bytes = self.lid.serialize(); + let terminate_bytes = self.terminate.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FREE_LEASE_REQUEST, + 0, + 0, + lid_bytes[0], + lid_bytes[1], + lid_bytes[2], + lid_bytes[3], + terminate_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn free_lease(conn: &Conn, lid: Lease, terminate: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let lid_bytes = lid.serialize(); - let terminate_bytes = terminate.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FREE_LEASE_REQUEST, - 0, - 0, - lid_bytes[0], - lid_bytes[1], - lid_bytes[2], - lid_bytes[3], - terminate_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FreeLeaseRequest { + lid, + terminate, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -5089,11 +6083,11 @@ pub trait ConnectionExt: RequestConnection { { query_output_property(self, output, property) } - fn randr_configure_output_property<'c>(&'c self, output: Output, property: xproto::Atom, pending: bool, range: bool, values: &[i32]) -> Result, ConnectionError> + fn randr_configure_output_property<'c, 'input>(&'c self, output: Output, property: xproto::Atom, pending: bool, range: bool, values: &'input [i32]) -> Result, ConnectionError> { configure_output_property(self, output, property, pending, range, values) } - fn randr_change_output_property<'c>(&'c self, output: Output, property: xproto::Atom, type_: xproto::Atom, format: u8, mode: xproto::PropMode, num_units: u32, data: &[u8]) -> Result, ConnectionError> + fn randr_change_output_property<'c, 'input>(&'c self, output: Output, property: xproto::Atom, type_: xproto::Atom, format: u8, mode: xproto::PropMode, num_units: u32, data: &'input [u8]) -> Result, ConnectionError> { change_output_property(self, output, property, type_, format, mode, num_units, data) } @@ -5107,7 +6101,7 @@ pub trait ConnectionExt: RequestConnection { { get_output_property(self, output, property, type_, long_offset, long_length, delete, pending) } - fn randr_create_mode<'c>(&'c self, window: xproto::Window, mode_info: ModeInfo, name: &[u8]) -> Result, ConnectionError> + fn randr_create_mode<'c, 'input>(&'c self, window: xproto::Window, mode_info: ModeInfo, name: &'input [u8]) -> Result, ConnectionError> { create_mode(self, window, mode_info, name) } @@ -5127,7 +6121,7 @@ pub trait ConnectionExt: RequestConnection { { get_crtc_info(self, crtc, config_timestamp) } - fn randr_set_crtc_config<'c, A>(&'c self, crtc: Crtc, timestamp: xproto::Timestamp, config_timestamp: xproto::Timestamp, x: i16, y: i16, mode: Mode, rotation: A, outputs: &[Output]) -> Result, ConnectionError> + fn randr_set_crtc_config<'c, 'input, A>(&'c self, crtc: Crtc, timestamp: xproto::Timestamp, config_timestamp: xproto::Timestamp, x: i16, y: i16, mode: Mode, rotation: A, outputs: &'input [Output]) -> Result, ConnectionError> where A: Into, { @@ -5141,7 +6135,7 @@ pub trait ConnectionExt: RequestConnection { { get_crtc_gamma(self, crtc) } - fn randr_set_crtc_gamma<'c>(&'c self, crtc: Crtc, red: &[u16], green: &[u16], blue: &[u16]) -> Result, ConnectionError> + fn randr_set_crtc_gamma<'c, 'input>(&'c self, crtc: Crtc, red: &'input [u16], green: &'input [u16], blue: &'input [u16]) -> Result, ConnectionError> { set_crtc_gamma(self, crtc, red, green, blue) } @@ -5149,7 +6143,7 @@ pub trait ConnectionExt: RequestConnection { { get_screen_resources_current(self, window) } - fn randr_set_crtc_transform<'c>(&'c self, crtc: Crtc, transform: render::Transform, filter_name: &[u8], filter_params: &[render::Fixed]) -> Result, ConnectionError> + fn randr_set_crtc_transform<'c, 'input>(&'c self, crtc: Crtc, transform: render::Transform, filter_name: &'input [u8], filter_params: &'input [render::Fixed]) -> Result, ConnectionError> { set_crtc_transform(self, crtc, transform, filter_name, filter_params) } @@ -5197,11 +6191,11 @@ pub trait ConnectionExt: RequestConnection { { query_provider_property(self, provider, property) } - fn randr_configure_provider_property<'c>(&'c self, provider: Provider, property: xproto::Atom, pending: bool, range: bool, values: &[i32]) -> Result, ConnectionError> + fn randr_configure_provider_property<'c, 'input>(&'c self, provider: Provider, property: xproto::Atom, pending: bool, range: bool, values: &'input [i32]) -> Result, ConnectionError> { configure_provider_property(self, provider, property, pending, range, values) } - fn randr_change_provider_property<'c>(&'c self, provider: Provider, property: xproto::Atom, type_: xproto::Atom, format: u8, mode: u8, num_items: u32, data: &[u8]) -> Result, ConnectionError> + fn randr_change_provider_property<'c, 'input>(&'c self, provider: Provider, property: xproto::Atom, type_: xproto::Atom, format: u8, mode: u8, num_items: u32, data: &'input [u8]) -> Result, ConnectionError> { change_provider_property(self, provider, property, type_, format, mode, num_items, data) } @@ -5225,7 +6219,7 @@ pub trait ConnectionExt: RequestConnection { { delete_monitor(self, window, name) } - fn randr_create_lease<'c>(&'c self, window: xproto::Window, lid: Lease, crtcs: &[Crtc], outputs: &[Output]) -> Result, ConnectionError> + fn randr_create_lease<'c, 'input>(&'c self, window: xproto::Window, lid: Lease, crtcs: &'input [Crtc], outputs: &'input [Output]) -> Result, ConnectionError> { create_lease(self, window, lid, crtcs, outputs) } diff --git a/src/protocol/record.rs b/src/protocol/record.rs index f44b7164..6f406da7 100644 --- a/src/protocol/record.rs +++ b/src/protocol/record.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -496,30 +496,50 @@ impl From for [u8; 32] { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub major_version: u16, + pub minor_version: u16, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + major_version_bytes[0], + major_version_bytes[1], + minor_version_bytes[0], + minor_version_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, major_version: u16, minor_version: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - major_version_bytes[0], - major_version_bytes[1], - minor_version_bytes[0], - minor_version_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + major_version, + minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -551,166 +571,252 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the CreateContext request pub const CREATE_CONTEXT_REQUEST: u8 = 1; -pub fn create_context<'c, Conn>(conn: &'c Conn, context: Context, element_header: ElementHeader, client_specs: &[ClientSpec], ranges: &[Range]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateContextRequest<'input> { + pub context: Context, + pub element_header: ElementHeader, + pub client_specs: &'input [ClientSpec], + pub ranges: &'input [Range], +} +impl<'input> CreateContextRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let element_header_bytes = self.element_header.serialize(); + let num_client_specs = u32::try_from(self.client_specs.len()).expect("`client_specs` has too many elements"); + let num_client_specs_bytes = num_client_specs.serialize(); + let num_ranges = u32::try_from(self.ranges.len()).expect("`ranges` has too many elements"); + let num_ranges_bytes = num_ranges.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + element_header_bytes[0], + 0, + 0, + 0, + num_client_specs_bytes[0], + num_client_specs_bytes[1], + num_client_specs_bytes[2], + num_client_specs_bytes[3], + num_ranges_bytes[0], + num_ranges_bytes[1], + num_ranges_bytes[2], + num_ranges_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let client_specs_bytes = self.client_specs.serialize(); + let length_so_far = length_so_far + client_specs_bytes.len(); + let ranges_bytes = self.ranges.serialize(); + let length_so_far = length_so_far + ranges_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), client_specs_bytes.into(), ranges_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_context<'c, 'input, Conn>(conn: &'c Conn, context: Context, element_header: ElementHeader, client_specs: &'input [ClientSpec], ranges: &'input [Range]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let element_header_bytes = element_header.serialize(); - let num_client_specs = u32::try_from(client_specs.len()).expect("`client_specs` has too many elements"); - let num_client_specs_bytes = num_client_specs.serialize(); - let num_ranges = u32::try_from(ranges.len()).expect("`ranges` has too many elements"); - let num_ranges_bytes = num_ranges.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - element_header_bytes[0], - 0, - 0, - 0, - num_client_specs_bytes[0], - num_client_specs_bytes[1], - num_client_specs_bytes[2], - num_client_specs_bytes[3], - num_ranges_bytes[0], - num_ranges_bytes[1], - num_ranges_bytes[2], - num_ranges_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let client_specs_bytes = client_specs.serialize(); - let length_so_far = length_so_far + client_specs_bytes.len(); - let ranges_bytes = ranges.serialize(); - let length_so_far = length_so_far + ranges_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&client_specs_bytes), IoSlice::new(&ranges_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateContextRequest { + context, + element_header, + client_specs, + ranges, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the RegisterClients request pub const REGISTER_CLIENTS_REQUEST: u8 = 2; -pub fn register_clients<'c, Conn>(conn: &'c Conn, context: Context, element_header: ElementHeader, client_specs: &[ClientSpec], ranges: &[Range]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RegisterClientsRequest<'input> { + pub context: Context, + pub element_header: ElementHeader, + pub client_specs: &'input [ClientSpec], + pub ranges: &'input [Range], +} +impl<'input> RegisterClientsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let element_header_bytes = self.element_header.serialize(); + let num_client_specs = u32::try_from(self.client_specs.len()).expect("`client_specs` has too many elements"); + let num_client_specs_bytes = num_client_specs.serialize(); + let num_ranges = u32::try_from(self.ranges.len()).expect("`ranges` has too many elements"); + let num_ranges_bytes = num_ranges.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + REGISTER_CLIENTS_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + element_header_bytes[0], + 0, + 0, + 0, + num_client_specs_bytes[0], + num_client_specs_bytes[1], + num_client_specs_bytes[2], + num_client_specs_bytes[3], + num_ranges_bytes[0], + num_ranges_bytes[1], + num_ranges_bytes[2], + num_ranges_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let client_specs_bytes = self.client_specs.serialize(); + let length_so_far = length_so_far + client_specs_bytes.len(); + let ranges_bytes = self.ranges.serialize(); + let length_so_far = length_so_far + ranges_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), client_specs_bytes.into(), ranges_bytes.into(), padding0.into()], vec![])) + } +} +pub fn register_clients<'c, 'input, Conn>(conn: &'c Conn, context: Context, element_header: ElementHeader, client_specs: &'input [ClientSpec], ranges: &'input [Range]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let element_header_bytes = element_header.serialize(); - let num_client_specs = u32::try_from(client_specs.len()).expect("`client_specs` has too many elements"); - let num_client_specs_bytes = num_client_specs.serialize(); - let num_ranges = u32::try_from(ranges.len()).expect("`ranges` has too many elements"); - let num_ranges_bytes = num_ranges.serialize(); - let mut request0 = [ - extension_information.major_opcode, - REGISTER_CLIENTS_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - element_header_bytes[0], - 0, - 0, - 0, - num_client_specs_bytes[0], - num_client_specs_bytes[1], - num_client_specs_bytes[2], - num_client_specs_bytes[3], - num_ranges_bytes[0], - num_ranges_bytes[1], - num_ranges_bytes[2], - num_ranges_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let client_specs_bytes = client_specs.serialize(); - let length_so_far = length_so_far + client_specs_bytes.len(); - let ranges_bytes = ranges.serialize(); - let length_so_far = length_so_far + ranges_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&client_specs_bytes), IoSlice::new(&ranges_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = RegisterClientsRequest { + context, + element_header, + client_specs, + ranges, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UnregisterClients request pub const UNREGISTER_CLIENTS_REQUEST: u8 = 3; -pub fn unregister_clients<'c, Conn>(conn: &'c Conn, context: Context, client_specs: &[ClientSpec]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct UnregisterClientsRequest<'input> { + pub context: Context, + pub client_specs: &'input [ClientSpec], +} +impl<'input> UnregisterClientsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let num_client_specs = u32::try_from(self.client_specs.len()).expect("`client_specs` has too many elements"); + let num_client_specs_bytes = num_client_specs.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + UNREGISTER_CLIENTS_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + num_client_specs_bytes[0], + num_client_specs_bytes[1], + num_client_specs_bytes[2], + num_client_specs_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let client_specs_bytes = self.client_specs.serialize(); + let length_so_far = length_so_far + client_specs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), client_specs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn unregister_clients<'c, 'input, Conn>(conn: &'c Conn, context: Context, client_specs: &'input [ClientSpec]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let num_client_specs = u32::try_from(client_specs.len()).expect("`client_specs` has too many elements"); - let num_client_specs_bytes = num_client_specs.serialize(); - let mut request0 = [ - extension_information.major_opcode, - UNREGISTER_CLIENTS_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - num_client_specs_bytes[0], - num_client_specs_bytes[1], - num_client_specs_bytes[2], - num_client_specs_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let client_specs_bytes = client_specs.serialize(); - let length_so_far = length_so_far + client_specs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&client_specs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = UnregisterClientsRequest { + context, + client_specs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetContext request pub const GET_CONTEXT_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetContextRequest { + pub context: Context, +} +impl GetContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_context(conn: &Conn, context: Context) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -761,29 +867,47 @@ impl GetContextReply { /// Opcode for the EnableContext request pub const ENABLE_CONTEXT_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct EnableContextRequest { + pub context: Context, +} +impl EnableContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + ENABLE_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn enable_context(conn: &Conn, context: Context) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - ENABLE_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = EnableContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -842,56 +966,92 @@ impl EnableContextReply { /// Opcode for the DisableContext request pub const DISABLE_CONTEXT_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DisableContextRequest { + pub context: Context, +} +impl DisableContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DISABLE_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn disable_context(conn: &Conn, context: Context) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DISABLE_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DisableContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the FreeContext request pub const FREE_CONTEXT_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FreeContextRequest { + pub context: Context, +} +impl FreeContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FREE_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn free_context(conn: &Conn, context: Context) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FREE_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FreeContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Extension trait defining the requests of this extension. @@ -900,15 +1060,15 @@ pub trait ConnectionExt: RequestConnection { { query_version(self, major_version, minor_version) } - fn record_create_context<'c>(&'c self, context: Context, element_header: ElementHeader, client_specs: &[ClientSpec], ranges: &[Range]) -> Result, ConnectionError> + fn record_create_context<'c, 'input>(&'c self, context: Context, element_header: ElementHeader, client_specs: &'input [ClientSpec], ranges: &'input [Range]) -> Result, ConnectionError> { create_context(self, context, element_header, client_specs, ranges) } - fn record_register_clients<'c>(&'c self, context: Context, element_header: ElementHeader, client_specs: &[ClientSpec], ranges: &[Range]) -> Result, ConnectionError> + fn record_register_clients<'c, 'input>(&'c self, context: Context, element_header: ElementHeader, client_specs: &'input [ClientSpec], ranges: &'input [Range]) -> Result, ConnectionError> { register_clients(self, context, element_header, client_specs, ranges) } - fn record_unregister_clients<'c>(&'c self, context: Context, client_specs: &[ClientSpec]) -> Result, ConnectionError> + fn record_unregister_clients<'c, 'input>(&'c self, context: Context, client_specs: &'input [ClientSpec]) -> Result, ConnectionError> { unregister_clients(self, context, client_specs) } diff --git a/src/protocol/render.rs b/src/protocol/render.rs index a13f6f5d..3258659d 100644 --- a/src/protocol/render.rs +++ b/src/protocol/render.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -1811,34 +1811,54 @@ impl Serialize for Glyphinfo { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub client_major_version: u32, + pub client_minor_version: u32, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_version_bytes = self.client_major_version.serialize(); + let client_minor_version_bytes = self.client_minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + client_major_version_bytes[0], + client_major_version_bytes[1], + client_major_version_bytes[2], + client_major_version_bytes[3], + client_minor_version_bytes[0], + client_minor_version_bytes[1], + client_minor_version_bytes[2], + client_minor_version_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, client_major_version: u32, client_minor_version: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_version_bytes = client_major_version.serialize(); - let client_minor_version_bytes = client_minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - client_major_version_bytes[0], - client_major_version_bytes[1], - client_major_version_bytes[2], - client_major_version_bytes[3], - client_minor_version_bytes[0], - client_minor_version_bytes[1], - client_minor_version_bytes[2], - client_minor_version_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + client_major_version, + client_minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1871,24 +1891,38 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the QueryPictFormats request pub const QUERY_PICT_FORMATS_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryPictFormatsRequest; +impl QueryPictFormatsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_PICT_FORMATS_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_pict_formats(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - QUERY_PICT_FORMATS_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryPictFormatsRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1979,29 +2013,47 @@ impl QueryPictFormatsReply { /// Opcode for the QueryPictIndexValues request pub const QUERY_PICT_INDEX_VALUES_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryPictIndexValuesRequest { + pub format: Pictformat, +} +impl QueryPictIndexValuesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let format_bytes = self.format.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_PICT_INDEX_VALUES_REQUEST, + 0, + 0, + format_bytes[0], + format_bytes[1], + format_bytes[2], + format_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_pict_index_values(conn: &Conn, format: Pictformat) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let format_bytes = format.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_PICT_INDEX_VALUES_REQUEST, - 0, - 0, - format_bytes[0], - format_bytes[1], - format_bytes[2], - format_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryPictIndexValuesRequest { + format, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2046,8 +2098,6 @@ impl QueryPictIndexValuesReply { } } -/// Opcode for the CreatePicture request -pub const CREATE_PICTURE_REQUEST: u8 = 4; /// Auxiliary and optional information for the `create_picture` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct CreatePictureAux { @@ -2231,53 +2281,77 @@ impl CreatePictureAux { } } -pub fn create_picture<'c, Conn>(conn: &'c Conn, pid: Picture, drawable: xproto::Drawable, format: Pictformat, value_list: &CreatePictureAux) -> Result, ConnectionError> +/// Opcode for the CreatePicture request +pub const CREATE_PICTURE_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreatePictureRequest<'input> { + pub pid: Picture, + pub drawable: xproto::Drawable, + pub format: Pictformat, + pub value_list: &'input CreatePictureAux, +} +impl<'input> CreatePictureRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let pid_bytes = self.pid.serialize(); + let drawable_bytes = self.drawable.serialize(); + let format_bytes = self.format.serialize(); + let value_mask = u32::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_PICTURE_REQUEST, + 0, + 0, + pid_bytes[0], + pid_bytes[1], + pid_bytes[2], + pid_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + format_bytes[0], + format_bytes[1], + format_bytes[2], + format_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_picture<'c, 'input, Conn>(conn: &'c Conn, pid: Picture, drawable: xproto::Drawable, format: Pictformat, value_list: &'input CreatePictureAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let pid_bytes = pid.serialize(); - let drawable_bytes = drawable.serialize(); - let format_bytes = format.serialize(); - let value_mask = u32::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_PICTURE_REQUEST, - 0, - 0, - pid_bytes[0], - pid_bytes[1], - pid_bytes[2], - pid_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - format_bytes[0], - format_bytes[1], - format_bytes[2], - format_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreatePictureRequest { + pid, + drawable, + format, + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } -/// Opcode for the ChangePicture request -pub const CHANGE_PICTURE_REQUEST: u8 = 5; /// Auxiliary and optional information for the `change_picture` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct ChangePictureAux { @@ -2461,793 +2535,1263 @@ impl ChangePictureAux { } } -pub fn change_picture<'c, Conn>(conn: &'c Conn, picture: Picture, value_list: &ChangePictureAux) -> Result, ConnectionError> +/// Opcode for the ChangePicture request +pub const CHANGE_PICTURE_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangePictureRequest<'input> { + pub picture: Picture, + pub value_list: &'input ChangePictureAux, +} +impl<'input> ChangePictureRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let value_mask = u32::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_PICTURE_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) + } +} +pub fn change_picture<'c, 'input, Conn>(conn: &'c Conn, picture: Picture, value_list: &'input ChangePictureAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let value_mask = u32::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_PICTURE_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangePictureRequest { + picture, + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetPictureClipRectangles request pub const SET_PICTURE_CLIP_RECTANGLES_REQUEST: u8 = 6; -pub fn set_picture_clip_rectangles<'c, Conn>(conn: &'c Conn, picture: Picture, clip_x_origin: i16, clip_y_origin: i16, rectangles: &[xproto::Rectangle]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetPictureClipRectanglesRequest<'input> { + pub picture: Picture, + pub clip_x_origin: i16, + pub clip_y_origin: i16, + pub rectangles: &'input [xproto::Rectangle], +} +impl<'input> SetPictureClipRectanglesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let clip_x_origin_bytes = self.clip_x_origin.serialize(); + let clip_y_origin_bytes = self.clip_y_origin.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PICTURE_CLIP_RECTANGLES_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + clip_x_origin_bytes[0], + clip_x_origin_bytes[1], + clip_y_origin_bytes[0], + clip_y_origin_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let rectangles_bytes = self.rectangles.serialize(); + let length_so_far = length_so_far + rectangles_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), rectangles_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_picture_clip_rectangles<'c, 'input, Conn>(conn: &'c Conn, picture: Picture, clip_x_origin: i16, clip_y_origin: i16, rectangles: &'input [xproto::Rectangle]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let clip_x_origin_bytes = clip_x_origin.serialize(); - let clip_y_origin_bytes = clip_y_origin.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PICTURE_CLIP_RECTANGLES_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - clip_x_origin_bytes[0], - clip_x_origin_bytes[1], - clip_y_origin_bytes[0], - clip_y_origin_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let rectangles_bytes = rectangles.serialize(); - let length_so_far = length_so_far + rectangles_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&rectangles_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetPictureClipRectanglesRequest { + picture, + clip_x_origin, + clip_y_origin, + rectangles, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the FreePicture request pub const FREE_PICTURE_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FreePictureRequest { + pub picture: Picture, +} +impl FreePictureRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FREE_PICTURE_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn free_picture(conn: &Conn, picture: Picture) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FREE_PICTURE_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FreePictureRequest { + picture, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Composite request pub const COMPOSITE_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CompositeRequest { + pub op: PictOp, + pub src: Picture, + pub mask: Picture, + pub dst: Picture, + pub src_x: i16, + pub src_y: i16, + pub mask_x: i16, + pub mask_y: i16, + pub dst_x: i16, + pub dst_y: i16, + pub width: u16, + pub height: u16, +} +impl CompositeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let op_bytes = u8::from(self.op).serialize(); + let src_bytes = self.src.serialize(); + let mask_bytes = self.mask.serialize(); + let dst_bytes = self.dst.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let mask_x_bytes = self.mask_x.serialize(); + let mask_y_bytes = self.mask_y.serialize(); + let dst_x_bytes = self.dst_x.serialize(); + let dst_y_bytes = self.dst_y.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + COMPOSITE_REQUEST, + 0, + 0, + op_bytes[0], + 0, + 0, + 0, + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + mask_bytes[0], + mask_bytes[1], + mask_bytes[2], + mask_bytes[3], + dst_bytes[0], + dst_bytes[1], + dst_bytes[2], + dst_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + mask_x_bytes[0], + mask_x_bytes[1], + mask_y_bytes[0], + mask_y_bytes[1], + dst_x_bytes[0], + dst_x_bytes[1], + dst_y_bytes[0], + dst_y_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn composite(conn: &Conn, op: PictOp, src: Picture, mask: A, dst: Picture, src_x: i16, src_y: i16, mask_x: i16, mask_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let mask: Picture = mask.into(); - let length_so_far = 0; - let op_bytes = u8::from(op).serialize(); - let src_bytes = src.serialize(); - let mask_bytes = mask.serialize(); - let dst_bytes = dst.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let mask_x_bytes = mask_x.serialize(); - let mask_y_bytes = mask_y.serialize(); - let dst_x_bytes = dst_x.serialize(); - let dst_y_bytes = dst_y.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let mut request0 = [ - extension_information.major_opcode, - COMPOSITE_REQUEST, - 0, - 0, - op_bytes[0], - 0, - 0, - 0, - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - mask_bytes[0], - mask_bytes[1], - mask_bytes[2], - mask_bytes[3], - dst_bytes[0], - dst_bytes[1], - dst_bytes[2], - dst_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - mask_x_bytes[0], - mask_x_bytes[1], - mask_y_bytes[0], - mask_y_bytes[1], - dst_x_bytes[0], - dst_x_bytes[1], - dst_y_bytes[0], - dst_y_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CompositeRequest { + op, + src, + mask, + dst, + src_x, + src_y, + mask_x, + mask_y, + dst_x, + dst_y, + width, + height, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Trapezoids request pub const TRAPEZOIDS_REQUEST: u8 = 10; -pub fn trapezoids<'c, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, traps: &[Trapezoid]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TrapezoidsRequest<'input> { + pub op: PictOp, + pub src: Picture, + pub dst: Picture, + pub mask_format: Pictformat, + pub src_x: i16, + pub src_y: i16, + pub traps: &'input [Trapezoid], +} +impl<'input> TrapezoidsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let op_bytes = u8::from(self.op).serialize(); + let src_bytes = self.src.serialize(); + let dst_bytes = self.dst.serialize(); + let mask_format_bytes = self.mask_format.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + TRAPEZOIDS_REQUEST, + 0, + 0, + op_bytes[0], + 0, + 0, + 0, + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + dst_bytes[0], + dst_bytes[1], + dst_bytes[2], + dst_bytes[3], + mask_format_bytes[0], + mask_format_bytes[1], + mask_format_bytes[2], + mask_format_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let traps_bytes = self.traps.serialize(); + let length_so_far = length_so_far + traps_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), traps_bytes.into(), padding0.into()], vec![])) + } +} +pub fn trapezoids<'c, 'input, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, traps: &'input [Trapezoid]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let op_bytes = u8::from(op).serialize(); - let src_bytes = src.serialize(); - let dst_bytes = dst.serialize(); - let mask_format_bytes = mask_format.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let mut request0 = [ - extension_information.major_opcode, - TRAPEZOIDS_REQUEST, - 0, - 0, - op_bytes[0], - 0, - 0, - 0, - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - dst_bytes[0], - dst_bytes[1], - dst_bytes[2], - dst_bytes[3], - mask_format_bytes[0], - mask_format_bytes[1], - mask_format_bytes[2], - mask_format_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let traps_bytes = traps.serialize(); - let length_so_far = length_so_far + traps_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&traps_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = TrapezoidsRequest { + op, + src, + dst, + mask_format, + src_x, + src_y, + traps, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Triangles request pub const TRIANGLES_REQUEST: u8 = 11; -pub fn triangles<'c, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, triangles: &[Triangle]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TrianglesRequest<'input> { + pub op: PictOp, + pub src: Picture, + pub dst: Picture, + pub mask_format: Pictformat, + pub src_x: i16, + pub src_y: i16, + pub triangles: &'input [Triangle], +} +impl<'input> TrianglesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let op_bytes = u8::from(self.op).serialize(); + let src_bytes = self.src.serialize(); + let dst_bytes = self.dst.serialize(); + let mask_format_bytes = self.mask_format.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + TRIANGLES_REQUEST, + 0, + 0, + op_bytes[0], + 0, + 0, + 0, + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + dst_bytes[0], + dst_bytes[1], + dst_bytes[2], + dst_bytes[3], + mask_format_bytes[0], + mask_format_bytes[1], + mask_format_bytes[2], + mask_format_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let triangles_bytes = self.triangles.serialize(); + let length_so_far = length_so_far + triangles_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), triangles_bytes.into(), padding0.into()], vec![])) + } +} +pub fn triangles<'c, 'input, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, triangles: &'input [Triangle]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let op_bytes = u8::from(op).serialize(); - let src_bytes = src.serialize(); - let dst_bytes = dst.serialize(); - let mask_format_bytes = mask_format.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let mut request0 = [ - extension_information.major_opcode, - TRIANGLES_REQUEST, - 0, - 0, - op_bytes[0], - 0, - 0, - 0, - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - dst_bytes[0], - dst_bytes[1], - dst_bytes[2], - dst_bytes[3], - mask_format_bytes[0], - mask_format_bytes[1], - mask_format_bytes[2], - mask_format_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let triangles_bytes = triangles.serialize(); - let length_so_far = length_so_far + triangles_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&triangles_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = TrianglesRequest { + op, + src, + dst, + mask_format, + src_x, + src_y, + triangles, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the TriStrip request pub const TRI_STRIP_REQUEST: u8 = 12; -pub fn tri_strip<'c, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, points: &[Pointfix]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TriStripRequest<'input> { + pub op: PictOp, + pub src: Picture, + pub dst: Picture, + pub mask_format: Pictformat, + pub src_x: i16, + pub src_y: i16, + pub points: &'input [Pointfix], +} +impl<'input> TriStripRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let op_bytes = u8::from(self.op).serialize(); + let src_bytes = self.src.serialize(); + let dst_bytes = self.dst.serialize(); + let mask_format_bytes = self.mask_format.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + TRI_STRIP_REQUEST, + 0, + 0, + op_bytes[0], + 0, + 0, + 0, + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + dst_bytes[0], + dst_bytes[1], + dst_bytes[2], + dst_bytes[3], + mask_format_bytes[0], + mask_format_bytes[1], + mask_format_bytes[2], + mask_format_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let points_bytes = self.points.serialize(); + let length_so_far = length_so_far + points_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), points_bytes.into(), padding0.into()], vec![])) + } +} +pub fn tri_strip<'c, 'input, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, points: &'input [Pointfix]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let op_bytes = u8::from(op).serialize(); - let src_bytes = src.serialize(); - let dst_bytes = dst.serialize(); - let mask_format_bytes = mask_format.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let mut request0 = [ - extension_information.major_opcode, - TRI_STRIP_REQUEST, - 0, - 0, - op_bytes[0], - 0, - 0, - 0, - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - dst_bytes[0], - dst_bytes[1], - dst_bytes[2], - dst_bytes[3], - mask_format_bytes[0], - mask_format_bytes[1], - mask_format_bytes[2], - mask_format_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let points_bytes = points.serialize(); - let length_so_far = length_so_far + points_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&points_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = TriStripRequest { + op, + src, + dst, + mask_format, + src_x, + src_y, + points, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the TriFan request pub const TRI_FAN_REQUEST: u8 = 13; -pub fn tri_fan<'c, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, points: &[Pointfix]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TriFanRequest<'input> { + pub op: PictOp, + pub src: Picture, + pub dst: Picture, + pub mask_format: Pictformat, + pub src_x: i16, + pub src_y: i16, + pub points: &'input [Pointfix], +} +impl<'input> TriFanRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let op_bytes = u8::from(self.op).serialize(); + let src_bytes = self.src.serialize(); + let dst_bytes = self.dst.serialize(); + let mask_format_bytes = self.mask_format.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + TRI_FAN_REQUEST, + 0, + 0, + op_bytes[0], + 0, + 0, + 0, + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + dst_bytes[0], + dst_bytes[1], + dst_bytes[2], + dst_bytes[3], + mask_format_bytes[0], + mask_format_bytes[1], + mask_format_bytes[2], + mask_format_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let points_bytes = self.points.serialize(); + let length_so_far = length_so_far + points_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), points_bytes.into(), padding0.into()], vec![])) + } +} +pub fn tri_fan<'c, 'input, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, points: &'input [Pointfix]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let op_bytes = u8::from(op).serialize(); - let src_bytes = src.serialize(); - let dst_bytes = dst.serialize(); - let mask_format_bytes = mask_format.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let mut request0 = [ - extension_information.major_opcode, - TRI_FAN_REQUEST, - 0, - 0, - op_bytes[0], - 0, - 0, - 0, - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - dst_bytes[0], - dst_bytes[1], - dst_bytes[2], - dst_bytes[3], - mask_format_bytes[0], - mask_format_bytes[1], - mask_format_bytes[2], - mask_format_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let points_bytes = points.serialize(); - let length_so_far = length_so_far + points_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&points_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = TriFanRequest { + op, + src, + dst, + mask_format, + src_x, + src_y, + points, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateGlyphSet request pub const CREATE_GLYPH_SET_REQUEST: u8 = 17; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateGlyphSetRequest { + pub gsid: Glyphset, + pub format: Pictformat, +} +impl CreateGlyphSetRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let gsid_bytes = self.gsid.serialize(); + let format_bytes = self.format.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_GLYPH_SET_REQUEST, + 0, + 0, + gsid_bytes[0], + gsid_bytes[1], + gsid_bytes[2], + gsid_bytes[3], + format_bytes[0], + format_bytes[1], + format_bytes[2], + format_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_glyph_set(conn: &Conn, gsid: Glyphset, format: Pictformat) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let gsid_bytes = gsid.serialize(); - let format_bytes = format.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_GLYPH_SET_REQUEST, - 0, - 0, - gsid_bytes[0], - gsid_bytes[1], - gsid_bytes[2], - gsid_bytes[3], - format_bytes[0], - format_bytes[1], - format_bytes[2], - format_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateGlyphSetRequest { + gsid, + format, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ReferenceGlyphSet request pub const REFERENCE_GLYPH_SET_REQUEST: u8 = 18; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ReferenceGlyphSetRequest { + pub gsid: Glyphset, + pub existing: Glyphset, +} +impl ReferenceGlyphSetRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let gsid_bytes = self.gsid.serialize(); + let existing_bytes = self.existing.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + REFERENCE_GLYPH_SET_REQUEST, + 0, + 0, + gsid_bytes[0], + gsid_bytes[1], + gsid_bytes[2], + gsid_bytes[3], + existing_bytes[0], + existing_bytes[1], + existing_bytes[2], + existing_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn reference_glyph_set(conn: &Conn, gsid: Glyphset, existing: Glyphset) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let gsid_bytes = gsid.serialize(); - let existing_bytes = existing.serialize(); - let mut request0 = [ - extension_information.major_opcode, - REFERENCE_GLYPH_SET_REQUEST, - 0, - 0, - gsid_bytes[0], - gsid_bytes[1], - gsid_bytes[2], - gsid_bytes[3], - existing_bytes[0], - existing_bytes[1], - existing_bytes[2], - existing_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ReferenceGlyphSetRequest { + gsid, + existing, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the FreeGlyphSet request pub const FREE_GLYPH_SET_REQUEST: u8 = 19; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FreeGlyphSetRequest { + pub glyphset: Glyphset, +} +impl FreeGlyphSetRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let glyphset_bytes = self.glyphset.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FREE_GLYPH_SET_REQUEST, + 0, + 0, + glyphset_bytes[0], + glyphset_bytes[1], + glyphset_bytes[2], + glyphset_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn free_glyph_set(conn: &Conn, glyphset: Glyphset) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let glyphset_bytes = glyphset.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FREE_GLYPH_SET_REQUEST, - 0, - 0, - glyphset_bytes[0], - glyphset_bytes[1], - glyphset_bytes[2], - glyphset_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FreeGlyphSetRequest { + glyphset, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the AddGlyphs request pub const ADD_GLYPHS_REQUEST: u8 = 20; -pub fn add_glyphs<'c, Conn>(conn: &'c Conn, glyphset: Glyphset, glyphids: &[u32], glyphs: &[Glyphinfo], data: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AddGlyphsRequest<'input> { + pub glyphset: Glyphset, + pub glyphids: &'input [u32], + pub glyphs: &'input [Glyphinfo], + pub data: &'input [u8], +} +impl<'input> AddGlyphsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let glyphset_bytes = self.glyphset.serialize(); + let glyphs_len = u32::try_from(self.glyphids.len()).expect("`glyphids` has too many elements"); + let glyphs_len_bytes = glyphs_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + ADD_GLYPHS_REQUEST, + 0, + 0, + glyphset_bytes[0], + glyphset_bytes[1], + glyphset_bytes[2], + glyphset_bytes[3], + glyphs_len_bytes[0], + glyphs_len_bytes[1], + glyphs_len_bytes[2], + glyphs_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let glyphids_bytes = self.glyphids.serialize(); + let length_so_far = length_so_far + glyphids_bytes.len(); + assert_eq!(self.glyphs.len(), usize::try_from(glyphs_len).unwrap(), "`glyphs` has an incorrect length"); + let glyphs_bytes = self.glyphs.serialize(); + let length_so_far = length_so_far + glyphs_bytes.len(); + let length_so_far = length_so_far + (&self.data[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), glyphids_bytes.into(), glyphs_bytes.into(), (&self.data[..]).into(), padding0.into()], vec![])) + } +} +pub fn add_glyphs<'c, 'input, Conn>(conn: &'c Conn, glyphset: Glyphset, glyphids: &'input [u32], glyphs: &'input [Glyphinfo], data: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let glyphset_bytes = glyphset.serialize(); - let glyphs_len = u32::try_from(glyphids.len()).expect("`glyphids` has too many elements"); - let glyphs_len_bytes = glyphs_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - ADD_GLYPHS_REQUEST, - 0, - 0, - glyphset_bytes[0], - glyphset_bytes[1], - glyphset_bytes[2], - glyphset_bytes[3], - glyphs_len_bytes[0], - glyphs_len_bytes[1], - glyphs_len_bytes[2], - glyphs_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let glyphids_bytes = glyphids.serialize(); - let length_so_far = length_so_far + glyphids_bytes.len(); - assert_eq!(glyphs.len(), usize::try_from(glyphs_len).unwrap(), "`glyphs` has an incorrect length"); - let glyphs_bytes = glyphs.serialize(); - let length_so_far = length_so_far + glyphs_bytes.len(); - let length_so_far = length_so_far + data.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&glyphids_bytes), IoSlice::new(&glyphs_bytes), IoSlice::new(data), IoSlice::new(&padding0)], vec![])?) + let request0 = AddGlyphsRequest { + glyphset, + glyphids, + glyphs, + data, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the FreeGlyphs request pub const FREE_GLYPHS_REQUEST: u8 = 22; -pub fn free_glyphs<'c, Conn>(conn: &'c Conn, glyphset: Glyphset, glyphs: &[Glyph]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FreeGlyphsRequest<'input> { + pub glyphset: Glyphset, + pub glyphs: &'input [Glyph], +} +impl<'input> FreeGlyphsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let glyphset_bytes = self.glyphset.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FREE_GLYPHS_REQUEST, + 0, + 0, + glyphset_bytes[0], + glyphset_bytes[1], + glyphset_bytes[2], + glyphset_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let glyphs_bytes = self.glyphs.serialize(); + let length_so_far = length_so_far + glyphs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), glyphs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn free_glyphs<'c, 'input, Conn>(conn: &'c Conn, glyphset: Glyphset, glyphs: &'input [Glyph]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let glyphset_bytes = glyphset.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FREE_GLYPHS_REQUEST, - 0, - 0, - glyphset_bytes[0], - glyphset_bytes[1], - glyphset_bytes[2], - glyphset_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let glyphs_bytes = glyphs.serialize(); - let length_so_far = length_so_far + glyphs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&glyphs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = FreeGlyphsRequest { + glyphset, + glyphs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CompositeGlyphs8 request pub const COMPOSITE_GLYPHS8_REQUEST: u8 = 23; -pub fn composite_glyphs8<'c, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CompositeGlyphs8Request<'input> { + pub op: PictOp, + pub src: Picture, + pub dst: Picture, + pub mask_format: Pictformat, + pub glyphset: Glyphset, + pub src_x: i16, + pub src_y: i16, + pub glyphcmds: &'input [u8], +} +impl<'input> CompositeGlyphs8Request<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let op_bytes = u8::from(self.op).serialize(); + let src_bytes = self.src.serialize(); + let dst_bytes = self.dst.serialize(); + let mask_format_bytes = self.mask_format.serialize(); + let glyphset_bytes = self.glyphset.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + COMPOSITE_GLYPHS8_REQUEST, + 0, + 0, + op_bytes[0], + 0, + 0, + 0, + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + dst_bytes[0], + dst_bytes[1], + dst_bytes[2], + dst_bytes[3], + mask_format_bytes[0], + mask_format_bytes[1], + mask_format_bytes[2], + mask_format_bytes[3], + glyphset_bytes[0], + glyphset_bytes[1], + glyphset_bytes[2], + glyphset_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.glyphcmds[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.glyphcmds[..]).into(), padding0.into()], vec![])) + } +} +pub fn composite_glyphs8<'c, 'input, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let op_bytes = u8::from(op).serialize(); - let src_bytes = src.serialize(); - let dst_bytes = dst.serialize(); - let mask_format_bytes = mask_format.serialize(); - let glyphset_bytes = glyphset.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let mut request0 = [ - extension_information.major_opcode, - COMPOSITE_GLYPHS8_REQUEST, - 0, - 0, - op_bytes[0], - 0, - 0, - 0, - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - dst_bytes[0], - dst_bytes[1], - dst_bytes[2], - dst_bytes[3], - mask_format_bytes[0], - mask_format_bytes[1], - mask_format_bytes[2], - mask_format_bytes[3], - glyphset_bytes[0], - glyphset_bytes[1], - glyphset_bytes[2], - glyphset_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + glyphcmds.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(glyphcmds), IoSlice::new(&padding0)], vec![])?) + let request0 = CompositeGlyphs8Request { + op, + src, + dst, + mask_format, + glyphset, + src_x, + src_y, + glyphcmds, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CompositeGlyphs16 request pub const COMPOSITE_GLYPHS16_REQUEST: u8 = 24; -pub fn composite_glyphs16<'c, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CompositeGlyphs16Request<'input> { + pub op: PictOp, + pub src: Picture, + pub dst: Picture, + pub mask_format: Pictformat, + pub glyphset: Glyphset, + pub src_x: i16, + pub src_y: i16, + pub glyphcmds: &'input [u8], +} +impl<'input> CompositeGlyphs16Request<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let op_bytes = u8::from(self.op).serialize(); + let src_bytes = self.src.serialize(); + let dst_bytes = self.dst.serialize(); + let mask_format_bytes = self.mask_format.serialize(); + let glyphset_bytes = self.glyphset.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + COMPOSITE_GLYPHS16_REQUEST, + 0, + 0, + op_bytes[0], + 0, + 0, + 0, + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + dst_bytes[0], + dst_bytes[1], + dst_bytes[2], + dst_bytes[3], + mask_format_bytes[0], + mask_format_bytes[1], + mask_format_bytes[2], + mask_format_bytes[3], + glyphset_bytes[0], + glyphset_bytes[1], + glyphset_bytes[2], + glyphset_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.glyphcmds[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.glyphcmds[..]).into(), padding0.into()], vec![])) + } +} +pub fn composite_glyphs16<'c, 'input, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let op_bytes = u8::from(op).serialize(); - let src_bytes = src.serialize(); - let dst_bytes = dst.serialize(); - let mask_format_bytes = mask_format.serialize(); - let glyphset_bytes = glyphset.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let mut request0 = [ - extension_information.major_opcode, - COMPOSITE_GLYPHS16_REQUEST, - 0, - 0, - op_bytes[0], - 0, - 0, - 0, - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - dst_bytes[0], - dst_bytes[1], - dst_bytes[2], - dst_bytes[3], - mask_format_bytes[0], - mask_format_bytes[1], - mask_format_bytes[2], - mask_format_bytes[3], - glyphset_bytes[0], - glyphset_bytes[1], - glyphset_bytes[2], - glyphset_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + glyphcmds.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(glyphcmds), IoSlice::new(&padding0)], vec![])?) + let request0 = CompositeGlyphs16Request { + op, + src, + dst, + mask_format, + glyphset, + src_x, + src_y, + glyphcmds, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CompositeGlyphs32 request pub const COMPOSITE_GLYPHS32_REQUEST: u8 = 25; -pub fn composite_glyphs32<'c, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CompositeGlyphs32Request<'input> { + pub op: PictOp, + pub src: Picture, + pub dst: Picture, + pub mask_format: Pictformat, + pub glyphset: Glyphset, + pub src_x: i16, + pub src_y: i16, + pub glyphcmds: &'input [u8], +} +impl<'input> CompositeGlyphs32Request<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let op_bytes = u8::from(self.op).serialize(); + let src_bytes = self.src.serialize(); + let dst_bytes = self.dst.serialize(); + let mask_format_bytes = self.mask_format.serialize(); + let glyphset_bytes = self.glyphset.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + COMPOSITE_GLYPHS32_REQUEST, + 0, + 0, + op_bytes[0], + 0, + 0, + 0, + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + dst_bytes[0], + dst_bytes[1], + dst_bytes[2], + dst_bytes[3], + mask_format_bytes[0], + mask_format_bytes[1], + mask_format_bytes[2], + mask_format_bytes[3], + glyphset_bytes[0], + glyphset_bytes[1], + glyphset_bytes[2], + glyphset_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.glyphcmds[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.glyphcmds[..]).into(), padding0.into()], vec![])) + } +} +pub fn composite_glyphs32<'c, 'input, Conn>(conn: &'c Conn, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let op_bytes = u8::from(op).serialize(); - let src_bytes = src.serialize(); - let dst_bytes = dst.serialize(); - let mask_format_bytes = mask_format.serialize(); - let glyphset_bytes = glyphset.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let mut request0 = [ - extension_information.major_opcode, - COMPOSITE_GLYPHS32_REQUEST, - 0, - 0, - op_bytes[0], - 0, - 0, - 0, - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - dst_bytes[0], - dst_bytes[1], - dst_bytes[2], - dst_bytes[3], - mask_format_bytes[0], - mask_format_bytes[1], - mask_format_bytes[2], - mask_format_bytes[3], - glyphset_bytes[0], - glyphset_bytes[1], - glyphset_bytes[2], - glyphset_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + glyphcmds.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(glyphcmds), IoSlice::new(&padding0)], vec![])?) + let request0 = CompositeGlyphs32Request { + op, + src, + dst, + mask_format, + glyphset, + src_x, + src_y, + glyphcmds, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the FillRectangles request pub const FILL_RECTANGLES_REQUEST: u8 = 26; -pub fn fill_rectangles<'c, Conn>(conn: &'c Conn, op: PictOp, dst: Picture, color: Color, rects: &[xproto::Rectangle]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FillRectanglesRequest<'input> { + pub op: PictOp, + pub dst: Picture, + pub color: Color, + pub rects: &'input [xproto::Rectangle], +} +impl<'input> FillRectanglesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let op_bytes = u8::from(self.op).serialize(); + let dst_bytes = self.dst.serialize(); + let color_bytes = self.color.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FILL_RECTANGLES_REQUEST, + 0, + 0, + op_bytes[0], + 0, + 0, + 0, + dst_bytes[0], + dst_bytes[1], + dst_bytes[2], + dst_bytes[3], + color_bytes[0], + color_bytes[1], + color_bytes[2], + color_bytes[3], + color_bytes[4], + color_bytes[5], + color_bytes[6], + color_bytes[7], + ]; + let length_so_far = length_so_far + request0.len(); + let rects_bytes = self.rects.serialize(); + let length_so_far = length_so_far + rects_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), rects_bytes.into(), padding0.into()], vec![])) + } +} +pub fn fill_rectangles<'c, 'input, Conn>(conn: &'c Conn, op: PictOp, dst: Picture, color: Color, rects: &'input [xproto::Rectangle]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let op_bytes = u8::from(op).serialize(); - let dst_bytes = dst.serialize(); - let color_bytes = color.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FILL_RECTANGLES_REQUEST, - 0, - 0, - op_bytes[0], - 0, - 0, - 0, - dst_bytes[0], - dst_bytes[1], - dst_bytes[2], - dst_bytes[3], - color_bytes[0], - color_bytes[1], - color_bytes[2], - color_bytes[3], - color_bytes[4], - color_bytes[5], - color_bytes[6], - color_bytes[7], - ]; - let length_so_far = length_so_far + request0.len(); - let rects_bytes = rects.serialize(); - let length_so_far = length_so_far + rects_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&rects_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = FillRectanglesRequest { + op, + dst, + color, + rects, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateCursor request pub const CREATE_CURSOR_REQUEST: u8 = 27; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateCursorRequest { + pub cid: xproto::Cursor, + pub source: Picture, + pub x: u16, + pub y: u16, +} +impl CreateCursorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let cid_bytes = self.cid.serialize(); + let source_bytes = self.source.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_CURSOR_REQUEST, + 0, + 0, + cid_bytes[0], + cid_bytes[1], + cid_bytes[2], + cid_bytes[3], + source_bytes[0], + source_bytes[1], + source_bytes[2], + source_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_cursor(conn: &Conn, cid: xproto::Cursor, source: Picture, x: u16, y: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let cid_bytes = cid.serialize(); - let source_bytes = source.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_CURSOR_REQUEST, - 0, - 0, - cid_bytes[0], - cid_bytes[1], - cid_bytes[2], - cid_bytes[3], - source_bytes[0], - source_bytes[1], - source_bytes[2], - source_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateCursorRequest { + cid, + source, + x, + y, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -3350,93 +3894,131 @@ impl Serialize for Transform { /// Opcode for the SetPictureTransform request pub const SET_PICTURE_TRANSFORM_REQUEST: u8 = 28; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetPictureTransformRequest { + pub picture: Picture, + pub transform: Transform, +} +impl SetPictureTransformRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let transform_bytes = self.transform.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PICTURE_TRANSFORM_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + transform_bytes[0], + transform_bytes[1], + transform_bytes[2], + transform_bytes[3], + transform_bytes[4], + transform_bytes[5], + transform_bytes[6], + transform_bytes[7], + transform_bytes[8], + transform_bytes[9], + transform_bytes[10], + transform_bytes[11], + transform_bytes[12], + transform_bytes[13], + transform_bytes[14], + transform_bytes[15], + transform_bytes[16], + transform_bytes[17], + transform_bytes[18], + transform_bytes[19], + transform_bytes[20], + transform_bytes[21], + transform_bytes[22], + transform_bytes[23], + transform_bytes[24], + transform_bytes[25], + transform_bytes[26], + transform_bytes[27], + transform_bytes[28], + transform_bytes[29], + transform_bytes[30], + transform_bytes[31], + transform_bytes[32], + transform_bytes[33], + transform_bytes[34], + transform_bytes[35], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_picture_transform(conn: &Conn, picture: Picture, transform: Transform) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let transform_bytes = transform.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PICTURE_TRANSFORM_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - transform_bytes[0], - transform_bytes[1], - transform_bytes[2], - transform_bytes[3], - transform_bytes[4], - transform_bytes[5], - transform_bytes[6], - transform_bytes[7], - transform_bytes[8], - transform_bytes[9], - transform_bytes[10], - transform_bytes[11], - transform_bytes[12], - transform_bytes[13], - transform_bytes[14], - transform_bytes[15], - transform_bytes[16], - transform_bytes[17], - transform_bytes[18], - transform_bytes[19], - transform_bytes[20], - transform_bytes[21], - transform_bytes[22], - transform_bytes[23], - transform_bytes[24], - transform_bytes[25], - transform_bytes[26], - transform_bytes[27], - transform_bytes[28], - transform_bytes[29], - transform_bytes[30], - transform_bytes[31], - transform_bytes[32], - transform_bytes[33], - transform_bytes[34], - transform_bytes[35], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetPictureTransformRequest { + picture, + transform, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the QueryFilters request pub const QUERY_FILTERS_REQUEST: u8 = 29; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryFiltersRequest { + pub drawable: xproto::Drawable, +} +impl QueryFiltersRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_FILTERS_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_filters(conn: &Conn, drawable: xproto::Drawable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_FILTERS_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryFiltersRequest { + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -3499,42 +4081,64 @@ impl QueryFiltersReply { /// Opcode for the SetPictureFilter request pub const SET_PICTURE_FILTER_REQUEST: u8 = 30; -pub fn set_picture_filter<'c, Conn>(conn: &'c Conn, picture: Picture, filter: &[u8], values: &[Fixed]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetPictureFilterRequest<'input> { + pub picture: Picture, + pub filter: &'input [u8], + pub values: &'input [Fixed], +} +impl<'input> SetPictureFilterRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let filter_len = u16::try_from(self.filter.len()).expect("`filter` has too many elements"); + let filter_len_bytes = filter_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PICTURE_FILTER_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + filter_len_bytes[0], + filter_len_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.filter[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + let values_bytes = self.values.serialize(); + let length_so_far = length_so_far + values_bytes.len(); + let padding1 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding1.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.filter[..]).into(), padding0.into(), values_bytes.into(), padding1.into()], vec![])) + } +} +pub fn set_picture_filter<'c, 'input, Conn>(conn: &'c Conn, picture: Picture, filter: &'input [u8], values: &'input [Fixed]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let filter_len = u16::try_from(filter.len()).expect("`filter` has too many elements"); - let filter_len_bytes = filter_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PICTURE_FILTER_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - filter_len_bytes[0], - filter_len_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + filter.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - let values_bytes = values.serialize(); - let length_so_far = length_so_far + values_bytes.len(); - let padding1 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding1.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(filter), IoSlice::new(&padding0), IoSlice::new(&values_bytes), IoSlice::new(&padding1)], vec![])?) + let request0 = SetPictureFilterRequest { + picture, + filter, + values, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -3581,33 +4185,53 @@ impl Serialize for Animcursorelt { /// Opcode for the CreateAnimCursor request pub const CREATE_ANIM_CURSOR_REQUEST: u8 = 31; -pub fn create_anim_cursor<'c, Conn>(conn: &'c Conn, cid: xproto::Cursor, cursors: &[Animcursorelt]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateAnimCursorRequest<'input> { + pub cid: xproto::Cursor, + pub cursors: &'input [Animcursorelt], +} +impl<'input> CreateAnimCursorRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let cid_bytes = self.cid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_ANIM_CURSOR_REQUEST, + 0, + 0, + cid_bytes[0], + cid_bytes[1], + cid_bytes[2], + cid_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let cursors_bytes = self.cursors.serialize(); + let length_so_far = length_so_far + cursors_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), cursors_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_anim_cursor<'c, 'input, Conn>(conn: &'c Conn, cid: xproto::Cursor, cursors: &'input [Animcursorelt]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let cid_bytes = cid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_ANIM_CURSOR_REQUEST, - 0, - 0, - cid_bytes[0], - cid_bytes[1], - cid_bytes[2], - cid_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let cursors_bytes = cursors.serialize(); - let length_so_far = length_so_far + cursors_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&cursors_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateAnimCursorRequest { + cid, + cursors, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -3720,255 +4344,381 @@ impl Serialize for Trap { /// Opcode for the AddTraps request pub const ADD_TRAPS_REQUEST: u8 = 32; -pub fn add_traps<'c, Conn>(conn: &'c Conn, picture: Picture, x_off: i16, y_off: i16, traps: &[Trap]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AddTrapsRequest<'input> { + pub picture: Picture, + pub x_off: i16, + pub y_off: i16, + pub traps: &'input [Trap], +} +impl<'input> AddTrapsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let x_off_bytes = self.x_off.serialize(); + let y_off_bytes = self.y_off.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + ADD_TRAPS_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + x_off_bytes[0], + x_off_bytes[1], + y_off_bytes[0], + y_off_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let traps_bytes = self.traps.serialize(); + let length_so_far = length_so_far + traps_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), traps_bytes.into(), padding0.into()], vec![])) + } +} +pub fn add_traps<'c, 'input, Conn>(conn: &'c Conn, picture: Picture, x_off: i16, y_off: i16, traps: &'input [Trap]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let x_off_bytes = x_off.serialize(); - let y_off_bytes = y_off.serialize(); - let mut request0 = [ - extension_information.major_opcode, - ADD_TRAPS_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - x_off_bytes[0], - x_off_bytes[1], - y_off_bytes[0], - y_off_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let traps_bytes = traps.serialize(); - let length_so_far = length_so_far + traps_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&traps_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = AddTrapsRequest { + picture, + x_off, + y_off, + traps, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateSolidFill request pub const CREATE_SOLID_FILL_REQUEST: u8 = 33; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateSolidFillRequest { + pub picture: Picture, + pub color: Color, +} +impl CreateSolidFillRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let color_bytes = self.color.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_SOLID_FILL_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + color_bytes[0], + color_bytes[1], + color_bytes[2], + color_bytes[3], + color_bytes[4], + color_bytes[5], + color_bytes[6], + color_bytes[7], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_solid_fill(conn: &Conn, picture: Picture, color: Color) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let color_bytes = color.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_SOLID_FILL_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - color_bytes[0], - color_bytes[1], - color_bytes[2], - color_bytes[3], - color_bytes[4], - color_bytes[5], - color_bytes[6], - color_bytes[7], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateSolidFillRequest { + picture, + color, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateLinearGradient request pub const CREATE_LINEAR_GRADIENT_REQUEST: u8 = 34; -pub fn create_linear_gradient<'c, Conn>(conn: &'c Conn, picture: Picture, p1: Pointfix, p2: Pointfix, stops: &[Fixed], colors: &[Color]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateLinearGradientRequest<'input> { + pub picture: Picture, + pub p1: Pointfix, + pub p2: Pointfix, + pub stops: &'input [Fixed], + pub colors: &'input [Color], +} +impl<'input> CreateLinearGradientRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let p1_bytes = self.p1.serialize(); + let p2_bytes = self.p2.serialize(); + let num_stops = u32::try_from(self.stops.len()).expect("`stops` has too many elements"); + let num_stops_bytes = num_stops.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_LINEAR_GRADIENT_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + p1_bytes[0], + p1_bytes[1], + p1_bytes[2], + p1_bytes[3], + p1_bytes[4], + p1_bytes[5], + p1_bytes[6], + p1_bytes[7], + p2_bytes[0], + p2_bytes[1], + p2_bytes[2], + p2_bytes[3], + p2_bytes[4], + p2_bytes[5], + p2_bytes[6], + p2_bytes[7], + num_stops_bytes[0], + num_stops_bytes[1], + num_stops_bytes[2], + num_stops_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let stops_bytes = self.stops.serialize(); + let length_so_far = length_so_far + stops_bytes.len(); + assert_eq!(self.colors.len(), usize::try_from(num_stops).unwrap(), "`colors` has an incorrect length"); + let colors_bytes = self.colors.serialize(); + let length_so_far = length_so_far + colors_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), stops_bytes.into(), colors_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_linear_gradient<'c, 'input, Conn>(conn: &'c Conn, picture: Picture, p1: Pointfix, p2: Pointfix, stops: &'input [Fixed], colors: &'input [Color]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let p1_bytes = p1.serialize(); - let p2_bytes = p2.serialize(); - let num_stops = u32::try_from(stops.len()).expect("`stops` has too many elements"); - let num_stops_bytes = num_stops.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_LINEAR_GRADIENT_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - p1_bytes[0], - p1_bytes[1], - p1_bytes[2], - p1_bytes[3], - p1_bytes[4], - p1_bytes[5], - p1_bytes[6], - p1_bytes[7], - p2_bytes[0], - p2_bytes[1], - p2_bytes[2], - p2_bytes[3], - p2_bytes[4], - p2_bytes[5], - p2_bytes[6], - p2_bytes[7], - num_stops_bytes[0], - num_stops_bytes[1], - num_stops_bytes[2], - num_stops_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let stops_bytes = stops.serialize(); - let length_so_far = length_so_far + stops_bytes.len(); - assert_eq!(colors.len(), usize::try_from(num_stops).unwrap(), "`colors` has an incorrect length"); - let colors_bytes = colors.serialize(); - let length_so_far = length_so_far + colors_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&stops_bytes), IoSlice::new(&colors_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateLinearGradientRequest { + picture, + p1, + p2, + stops, + colors, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateRadialGradient request pub const CREATE_RADIAL_GRADIENT_REQUEST: u8 = 35; -pub fn create_radial_gradient<'c, Conn>(conn: &'c Conn, picture: Picture, inner: Pointfix, outer: Pointfix, inner_radius: Fixed, outer_radius: Fixed, stops: &[Fixed], colors: &[Color]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateRadialGradientRequest<'input> { + pub picture: Picture, + pub inner: Pointfix, + pub outer: Pointfix, + pub inner_radius: Fixed, + pub outer_radius: Fixed, + pub stops: &'input [Fixed], + pub colors: &'input [Color], +} +impl<'input> CreateRadialGradientRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let inner_bytes = self.inner.serialize(); + let outer_bytes = self.outer.serialize(); + let inner_radius_bytes = self.inner_radius.serialize(); + let outer_radius_bytes = self.outer_radius.serialize(); + let num_stops = u32::try_from(self.stops.len()).expect("`stops` has too many elements"); + let num_stops_bytes = num_stops.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_RADIAL_GRADIENT_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + inner_bytes[0], + inner_bytes[1], + inner_bytes[2], + inner_bytes[3], + inner_bytes[4], + inner_bytes[5], + inner_bytes[6], + inner_bytes[7], + outer_bytes[0], + outer_bytes[1], + outer_bytes[2], + outer_bytes[3], + outer_bytes[4], + outer_bytes[5], + outer_bytes[6], + outer_bytes[7], + inner_radius_bytes[0], + inner_radius_bytes[1], + inner_radius_bytes[2], + inner_radius_bytes[3], + outer_radius_bytes[0], + outer_radius_bytes[1], + outer_radius_bytes[2], + outer_radius_bytes[3], + num_stops_bytes[0], + num_stops_bytes[1], + num_stops_bytes[2], + num_stops_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let stops_bytes = self.stops.serialize(); + let length_so_far = length_so_far + stops_bytes.len(); + assert_eq!(self.colors.len(), usize::try_from(num_stops).unwrap(), "`colors` has an incorrect length"); + let colors_bytes = self.colors.serialize(); + let length_so_far = length_so_far + colors_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), stops_bytes.into(), colors_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_radial_gradient<'c, 'input, Conn>(conn: &'c Conn, picture: Picture, inner: Pointfix, outer: Pointfix, inner_radius: Fixed, outer_radius: Fixed, stops: &'input [Fixed], colors: &'input [Color]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let inner_bytes = inner.serialize(); - let outer_bytes = outer.serialize(); - let inner_radius_bytes = inner_radius.serialize(); - let outer_radius_bytes = outer_radius.serialize(); - let num_stops = u32::try_from(stops.len()).expect("`stops` has too many elements"); - let num_stops_bytes = num_stops.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_RADIAL_GRADIENT_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - inner_bytes[0], - inner_bytes[1], - inner_bytes[2], - inner_bytes[3], - inner_bytes[4], - inner_bytes[5], - inner_bytes[6], - inner_bytes[7], - outer_bytes[0], - outer_bytes[1], - outer_bytes[2], - outer_bytes[3], - outer_bytes[4], - outer_bytes[5], - outer_bytes[6], - outer_bytes[7], - inner_radius_bytes[0], - inner_radius_bytes[1], - inner_radius_bytes[2], - inner_radius_bytes[3], - outer_radius_bytes[0], - outer_radius_bytes[1], - outer_radius_bytes[2], - outer_radius_bytes[3], - num_stops_bytes[0], - num_stops_bytes[1], - num_stops_bytes[2], - num_stops_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let stops_bytes = stops.serialize(); - let length_so_far = length_so_far + stops_bytes.len(); - assert_eq!(colors.len(), usize::try_from(num_stops).unwrap(), "`colors` has an incorrect length"); - let colors_bytes = colors.serialize(); - let length_so_far = length_so_far + colors_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&stops_bytes), IoSlice::new(&colors_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateRadialGradientRequest { + picture, + inner, + outer, + inner_radius, + outer_radius, + stops, + colors, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateConicalGradient request pub const CREATE_CONICAL_GRADIENT_REQUEST: u8 = 36; -pub fn create_conical_gradient<'c, Conn>(conn: &'c Conn, picture: Picture, center: Pointfix, angle: Fixed, stops: &[Fixed], colors: &[Color]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateConicalGradientRequest<'input> { + pub picture: Picture, + pub center: Pointfix, + pub angle: Fixed, + pub stops: &'input [Fixed], + pub colors: &'input [Color], +} +impl<'input> CreateConicalGradientRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let center_bytes = self.center.serialize(); + let angle_bytes = self.angle.serialize(); + let num_stops = u32::try_from(self.stops.len()).expect("`stops` has too many elements"); + let num_stops_bytes = num_stops.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_CONICAL_GRADIENT_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + center_bytes[0], + center_bytes[1], + center_bytes[2], + center_bytes[3], + center_bytes[4], + center_bytes[5], + center_bytes[6], + center_bytes[7], + angle_bytes[0], + angle_bytes[1], + angle_bytes[2], + angle_bytes[3], + num_stops_bytes[0], + num_stops_bytes[1], + num_stops_bytes[2], + num_stops_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let stops_bytes = self.stops.serialize(); + let length_so_far = length_so_far + stops_bytes.len(); + assert_eq!(self.colors.len(), usize::try_from(num_stops).unwrap(), "`colors` has an incorrect length"); + let colors_bytes = self.colors.serialize(); + let length_so_far = length_so_far + colors_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), stops_bytes.into(), colors_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_conical_gradient<'c, 'input, Conn>(conn: &'c Conn, picture: Picture, center: Pointfix, angle: Fixed, stops: &'input [Fixed], colors: &'input [Color]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let center_bytes = center.serialize(); - let angle_bytes = angle.serialize(); - let num_stops = u32::try_from(stops.len()).expect("`stops` has too many elements"); - let num_stops_bytes = num_stops.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_CONICAL_GRADIENT_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - center_bytes[0], - center_bytes[1], - center_bytes[2], - center_bytes[3], - center_bytes[4], - center_bytes[5], - center_bytes[6], - center_bytes[7], - angle_bytes[0], - angle_bytes[1], - angle_bytes[2], - angle_bytes[3], - num_stops_bytes[0], - num_stops_bytes[1], - num_stops_bytes[2], - num_stops_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let stops_bytes = stops.serialize(); - let length_so_far = length_so_far + stops_bytes.len(); - assert_eq!(colors.len(), usize::try_from(num_stops).unwrap(), "`colors` has an incorrect length"); - let colors_bytes = colors.serialize(); - let length_so_far = length_so_far + colors_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&stops_bytes), IoSlice::new(&colors_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateConicalGradientRequest { + picture, + center, + angle, + stops, + colors, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Extension trait defining the requests of this extension. @@ -3985,15 +4735,15 @@ pub trait ConnectionExt: RequestConnection { { query_pict_index_values(self, format) } - fn render_create_picture<'c>(&'c self, pid: Picture, drawable: xproto::Drawable, format: Pictformat, value_list: &CreatePictureAux) -> Result, ConnectionError> + fn render_create_picture<'c, 'input>(&'c self, pid: Picture, drawable: xproto::Drawable, format: Pictformat, value_list: &'input CreatePictureAux) -> Result, ConnectionError> { create_picture(self, pid, drawable, format, value_list) } - fn render_change_picture<'c>(&'c self, picture: Picture, value_list: &ChangePictureAux) -> Result, ConnectionError> + fn render_change_picture<'c, 'input>(&'c self, picture: Picture, value_list: &'input ChangePictureAux) -> Result, ConnectionError> { change_picture(self, picture, value_list) } - fn render_set_picture_clip_rectangles<'c>(&'c self, picture: Picture, clip_x_origin: i16, clip_y_origin: i16, rectangles: &[xproto::Rectangle]) -> Result, ConnectionError> + fn render_set_picture_clip_rectangles<'c, 'input>(&'c self, picture: Picture, clip_x_origin: i16, clip_y_origin: i16, rectangles: &'input [xproto::Rectangle]) -> Result, ConnectionError> { set_picture_clip_rectangles(self, picture, clip_x_origin, clip_y_origin, rectangles) } @@ -4007,19 +4757,19 @@ pub trait ConnectionExt: RequestConnection { { composite(self, op, src, mask, dst, src_x, src_y, mask_x, mask_y, dst_x, dst_y, width, height) } - fn render_trapezoids<'c>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, traps: &[Trapezoid]) -> Result, ConnectionError> + fn render_trapezoids<'c, 'input>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, traps: &'input [Trapezoid]) -> Result, ConnectionError> { trapezoids(self, op, src, dst, mask_format, src_x, src_y, traps) } - fn render_triangles<'c>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, triangles: &[Triangle]) -> Result, ConnectionError> + fn render_triangles<'c, 'input>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, triangles: &'input [Triangle]) -> Result, ConnectionError> { self::triangles(self, op, src, dst, mask_format, src_x, src_y, triangles) } - fn render_tri_strip<'c>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, points: &[Pointfix]) -> Result, ConnectionError> + fn render_tri_strip<'c, 'input>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, points: &'input [Pointfix]) -> Result, ConnectionError> { tri_strip(self, op, src, dst, mask_format, src_x, src_y, points) } - fn render_tri_fan<'c>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, points: &[Pointfix]) -> Result, ConnectionError> + fn render_tri_fan<'c, 'input>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, src_x: i16, src_y: i16, points: &'input [Pointfix]) -> Result, ConnectionError> { tri_fan(self, op, src, dst, mask_format, src_x, src_y, points) } @@ -4035,27 +4785,27 @@ pub trait ConnectionExt: RequestConnection { { free_glyph_set(self, glyphset) } - fn render_add_glyphs<'c>(&'c self, glyphset: Glyphset, glyphids: &[u32], glyphs: &[Glyphinfo], data: &[u8]) -> Result, ConnectionError> + fn render_add_glyphs<'c, 'input>(&'c self, glyphset: Glyphset, glyphids: &'input [u32], glyphs: &'input [Glyphinfo], data: &'input [u8]) -> Result, ConnectionError> { add_glyphs(self, glyphset, glyphids, glyphs, data) } - fn render_free_glyphs<'c>(&'c self, glyphset: Glyphset, glyphs: &[Glyph]) -> Result, ConnectionError> + fn render_free_glyphs<'c, 'input>(&'c self, glyphset: Glyphset, glyphs: &'input [Glyph]) -> Result, ConnectionError> { free_glyphs(self, glyphset, glyphs) } - fn render_composite_glyphs8<'c>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &[u8]) -> Result, ConnectionError> + fn render_composite_glyphs8<'c, 'input>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &'input [u8]) -> Result, ConnectionError> { composite_glyphs8(self, op, src, dst, mask_format, glyphset, src_x, src_y, glyphcmds) } - fn render_composite_glyphs16<'c>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &[u8]) -> Result, ConnectionError> + fn render_composite_glyphs16<'c, 'input>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &'input [u8]) -> Result, ConnectionError> { composite_glyphs16(self, op, src, dst, mask_format, glyphset, src_x, src_y, glyphcmds) } - fn render_composite_glyphs32<'c>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &[u8]) -> Result, ConnectionError> + fn render_composite_glyphs32<'c, 'input>(&'c self, op: PictOp, src: Picture, dst: Picture, mask_format: Pictformat, glyphset: Glyphset, src_x: i16, src_y: i16, glyphcmds: &'input [u8]) -> Result, ConnectionError> { composite_glyphs32(self, op, src, dst, mask_format, glyphset, src_x, src_y, glyphcmds) } - fn render_fill_rectangles<'c>(&'c self, op: PictOp, dst: Picture, color: Color, rects: &[xproto::Rectangle]) -> Result, ConnectionError> + fn render_fill_rectangles<'c, 'input>(&'c self, op: PictOp, dst: Picture, color: Color, rects: &'input [xproto::Rectangle]) -> Result, ConnectionError> { fill_rectangles(self, op, dst, color, rects) } @@ -4071,15 +4821,15 @@ pub trait ConnectionExt: RequestConnection { { query_filters(self, drawable) } - fn render_set_picture_filter<'c>(&'c self, picture: Picture, filter: &[u8], values: &[Fixed]) -> Result, ConnectionError> + fn render_set_picture_filter<'c, 'input>(&'c self, picture: Picture, filter: &'input [u8], values: &'input [Fixed]) -> Result, ConnectionError> { set_picture_filter(self, picture, filter, values) } - fn render_create_anim_cursor<'c>(&'c self, cid: xproto::Cursor, cursors: &[Animcursorelt]) -> Result, ConnectionError> + fn render_create_anim_cursor<'c, 'input>(&'c self, cid: xproto::Cursor, cursors: &'input [Animcursorelt]) -> Result, ConnectionError> { create_anim_cursor(self, cid, cursors) } - fn render_add_traps<'c>(&'c self, picture: Picture, x_off: i16, y_off: i16, traps: &[Trap]) -> Result, ConnectionError> + fn render_add_traps<'c, 'input>(&'c self, picture: Picture, x_off: i16, y_off: i16, traps: &'input [Trap]) -> Result, ConnectionError> { add_traps(self, picture, x_off, y_off, traps) } @@ -4087,15 +4837,15 @@ pub trait ConnectionExt: RequestConnection { { create_solid_fill(self, picture, color) } - fn render_create_linear_gradient<'c>(&'c self, picture: Picture, p1: Pointfix, p2: Pointfix, stops: &[Fixed], colors: &[Color]) -> Result, ConnectionError> + fn render_create_linear_gradient<'c, 'input>(&'c self, picture: Picture, p1: Pointfix, p2: Pointfix, stops: &'input [Fixed], colors: &'input [Color]) -> Result, ConnectionError> { create_linear_gradient(self, picture, p1, p2, stops, colors) } - fn render_create_radial_gradient<'c>(&'c self, picture: Picture, inner: Pointfix, outer: Pointfix, inner_radius: Fixed, outer_radius: Fixed, stops: &[Fixed], colors: &[Color]) -> Result, ConnectionError> + fn render_create_radial_gradient<'c, 'input>(&'c self, picture: Picture, inner: Pointfix, outer: Pointfix, inner_radius: Fixed, outer_radius: Fixed, stops: &'input [Fixed], colors: &'input [Color]) -> Result, ConnectionError> { create_radial_gradient(self, picture, inner, outer, inner_radius, outer_radius, stops, colors) } - fn render_create_conical_gradient<'c>(&'c self, picture: Picture, center: Pointfix, angle: Fixed, stops: &[Fixed], colors: &[Color]) -> Result, ConnectionError> + fn render_create_conical_gradient<'c, 'input>(&'c self, picture: Picture, center: Pointfix, angle: Fixed, stops: &'input [Fixed], colors: &'input [Color]) -> Result, ConnectionError> { create_conical_gradient(self, picture, center, angle, stops, colors) } diff --git a/src/protocol/res.rs b/src/protocol/res.rs index 2e7de38d..2d478dd3 100644 --- a/src/protocol/res.rs +++ b/src/protocol/res.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -431,30 +431,50 @@ impl ResourceSizeValue { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub client_major: u8, + pub client_minor: u8, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_bytes = self.client_major.serialize(); + let client_minor_bytes = self.client_minor.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + client_major_bytes[0], + client_minor_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, client_major: u8, client_minor: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_bytes = client_major.serialize(); - let client_minor_bytes = client_minor.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - client_major_bytes[0], - client_minor_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + client_major, + client_minor, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -486,24 +506,38 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the QueryClients request pub const QUERY_CLIENTS_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryClientsRequest; +impl QueryClientsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_CLIENTS_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_clients(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - QUERY_CLIENTS_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryClientsRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -550,29 +584,47 @@ impl QueryClientsReply { /// Opcode for the QueryClientResources request pub const QUERY_CLIENT_RESOURCES_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryClientResourcesRequest { + pub xid: u32, +} +impl QueryClientResourcesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let xid_bytes = self.xid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_CLIENT_RESOURCES_REQUEST, + 0, + 0, + xid_bytes[0], + xid_bytes[1], + xid_bytes[2], + xid_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_client_resources(conn: &Conn, xid: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let xid_bytes = xid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_CLIENT_RESOURCES_REQUEST, - 0, - 0, - xid_bytes[0], - xid_bytes[1], - xid_bytes[2], - xid_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryClientResourcesRequest { + xid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -619,29 +671,47 @@ impl QueryClientResourcesReply { /// Opcode for the QueryClientPixmapBytes request pub const QUERY_CLIENT_PIXMAP_BYTES_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryClientPixmapBytesRequest { + pub xid: u32, +} +impl QueryClientPixmapBytesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let xid_bytes = self.xid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_CLIENT_PIXMAP_BYTES_REQUEST, + 0, + 0, + xid_bytes[0], + xid_bytes[1], + xid_bytes[2], + xid_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_client_pixmap_bytes(conn: &Conn, xid: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let xid_bytes = xid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_CLIENT_PIXMAP_BYTES_REQUEST, - 0, - 0, - xid_bytes[0], - xid_bytes[1], - xid_bytes[2], - xid_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryClientPixmapBytesRequest { + xid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -673,34 +743,52 @@ impl TryFrom<&[u8]> for QueryClientPixmapBytesReply { /// Opcode for the QueryClientIds request pub const QUERY_CLIENT_IDS_REQUEST: u8 = 4; -pub fn query_client_ids<'c, Conn>(conn: &'c Conn, specs: &[ClientIdSpec]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct QueryClientIdsRequest<'input> { + pub specs: &'input [ClientIdSpec], +} +impl<'input> QueryClientIdsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let num_specs = u32::try_from(self.specs.len()).expect("`specs` has too many elements"); + let num_specs_bytes = num_specs.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_CLIENT_IDS_REQUEST, + 0, + 0, + num_specs_bytes[0], + num_specs_bytes[1], + num_specs_bytes[2], + num_specs_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let specs_bytes = self.specs.serialize(); + let length_so_far = length_so_far + specs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), specs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn query_client_ids<'c, 'input, Conn>(conn: &'c Conn, specs: &'input [ClientIdSpec]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let num_specs = u32::try_from(specs.len()).expect("`specs` has too many elements"); - let num_specs_bytes = num_specs.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_CLIENT_IDS_REQUEST, - 0, - 0, - num_specs_bytes[0], - num_specs_bytes[1], - num_specs_bytes[2], - num_specs_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let specs_bytes = specs.serialize(); - let length_so_far = length_so_far + specs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&specs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = QueryClientIdsRequest { + specs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -747,39 +835,59 @@ impl QueryClientIdsReply { /// Opcode for the QueryResourceBytes request pub const QUERY_RESOURCE_BYTES_REQUEST: u8 = 5; -pub fn query_resource_bytes<'c, Conn>(conn: &'c Conn, client: u32, specs: &[ResourceIdSpec]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct QueryResourceBytesRequest<'input> { + pub client: u32, + pub specs: &'input [ResourceIdSpec], +} +impl<'input> QueryResourceBytesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_bytes = self.client.serialize(); + let num_specs = u32::try_from(self.specs.len()).expect("`specs` has too many elements"); + let num_specs_bytes = num_specs.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_RESOURCE_BYTES_REQUEST, + 0, + 0, + client_bytes[0], + client_bytes[1], + client_bytes[2], + client_bytes[3], + num_specs_bytes[0], + num_specs_bytes[1], + num_specs_bytes[2], + num_specs_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let specs_bytes = self.specs.serialize(); + let length_so_far = length_so_far + specs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), specs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn query_resource_bytes<'c, 'input, Conn>(conn: &'c Conn, client: u32, specs: &'input [ResourceIdSpec]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_bytes = client.serialize(); - let num_specs = u32::try_from(specs.len()).expect("`specs` has too many elements"); - let num_specs_bytes = num_specs.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_RESOURCE_BYTES_REQUEST, - 0, - 0, - client_bytes[0], - client_bytes[1], - client_bytes[2], - client_bytes[3], - num_specs_bytes[0], - num_specs_bytes[1], - num_specs_bytes[2], - num_specs_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let specs_bytes = specs.serialize(); - let length_so_far = length_so_far + specs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&specs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = QueryResourceBytesRequest { + client, + specs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -842,11 +950,11 @@ pub trait ConnectionExt: RequestConnection { { query_client_pixmap_bytes(self, xid) } - fn res_query_client_ids<'c>(&'c self, specs: &[ClientIdSpec]) -> Result, ConnectionError> + fn res_query_client_ids<'c, 'input>(&'c self, specs: &'input [ClientIdSpec]) -> Result, ConnectionError> { query_client_ids(self, specs) } - fn res_query_resource_bytes<'c>(&'c self, client: u32, specs: &[ResourceIdSpec]) -> Result, ConnectionError> + fn res_query_resource_bytes<'c, 'input>(&'c self, client: u32, specs: &'input [ResourceIdSpec]) -> Result, ConnectionError> { query_resource_bytes(self, client, specs) } diff --git a/src/protocol/screensaver.rs b/src/protocol/screensaver.rs index 42c14b91..959da9bc 100644 --- a/src/protocol/screensaver.rs +++ b/src/protocol/screensaver.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -231,30 +231,50 @@ impl TryFrom for State { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub client_major_version: u8, + pub client_minor_version: u8, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_version_bytes = self.client_major_version.serialize(); + let client_minor_version_bytes = self.client_minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + client_major_version_bytes[0], + client_minor_version_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, client_major_version: u8, client_minor_version: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_version_bytes = client_major_version.serialize(); - let client_minor_version_bytes = client_minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - client_major_version_bytes[0], - client_minor_version_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + client_major_version, + client_minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -287,29 +307,47 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the QueryInfo request pub const QUERY_INFO_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryInfoRequest { + pub drawable: xproto::Drawable, +} +impl QueryInfoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_INFO_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_info(conn: &Conn, drawable: xproto::Drawable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_INFO_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryInfoRequest { + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -350,40 +388,58 @@ impl TryFrom<&[u8]> for QueryInfoReply { /// Opcode for the SelectInput request pub const SELECT_INPUT_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectInputRequest { + pub drawable: xproto::Drawable, + pub event_mask: u32, +} +impl SelectInputRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let event_mask_bytes = self.event_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_INPUT_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + event_mask_bytes[0], + event_mask_bytes[1], + event_mask_bytes[2], + event_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn select_input(conn: &Conn, drawable: xproto::Drawable, event_mask: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let event_mask: u32 = event_mask.into(); - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let event_mask_bytes = event_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_INPUT_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - event_mask_bytes[0], - event_mask_bytes[1], - event_mask_bytes[2], - event_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SelectInputRequest { + drawable, + event_mask, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } -/// Opcode for the SetAttributes request -pub const SET_ATTRIBUTES_REQUEST: u8 = 3; /// Auxiliary and optional information for the `set_attributes` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct SetAttributesAux { @@ -591,117 +647,191 @@ impl SetAttributesAux { } } -pub fn set_attributes<'c, Conn>(conn: &'c Conn, drawable: xproto::Drawable, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: xproto::WindowClass, depth: u8, visual: xproto::Visualid, value_list: &SetAttributesAux) -> Result, ConnectionError> +/// Opcode for the SetAttributes request +pub const SET_ATTRIBUTES_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetAttributesRequest<'input> { + pub drawable: xproto::Drawable, + pub x: i16, + pub y: i16, + pub width: u16, + pub height: u16, + pub border_width: u16, + pub class: xproto::WindowClass, + pub depth: u8, + pub visual: xproto::Visualid, + pub value_list: &'input SetAttributesAux, +} +impl<'input> SetAttributesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let border_width_bytes = self.border_width.serialize(); + let class_bytes = u8::from(self.class).serialize(); + let depth_bytes = self.depth.serialize(); + let visual_bytes = self.visual.serialize(); + let value_mask = u32::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_ATTRIBUTES_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + border_width_bytes[0], + border_width_bytes[1], + class_bytes[0], + depth_bytes[0], + visual_bytes[0], + visual_bytes[1], + visual_bytes[2], + visual_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_attributes<'c, 'input, Conn>(conn: &'c Conn, drawable: xproto::Drawable, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: xproto::WindowClass, depth: u8, visual: xproto::Visualid, value_list: &'input SetAttributesAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let border_width_bytes = border_width.serialize(); - let class_bytes = u8::from(class).serialize(); - let depth_bytes = depth.serialize(); - let visual_bytes = visual.serialize(); - let value_mask = u32::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_ATTRIBUTES_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - border_width_bytes[0], - border_width_bytes[1], - class_bytes[0], - depth_bytes[0], - visual_bytes[0], - visual_bytes[1], - visual_bytes[2], - visual_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetAttributesRequest { + drawable, + x, + y, + width, + height, + border_width, + class, + depth, + visual, + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UnsetAttributes request pub const UNSET_ATTRIBUTES_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UnsetAttributesRequest { + pub drawable: xproto::Drawable, +} +impl UnsetAttributesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + UNSET_ATTRIBUTES_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn unset_attributes(conn: &Conn, drawable: xproto::Drawable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - UNSET_ATTRIBUTES_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UnsetAttributesRequest { + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Suspend request pub const SUSPEND_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SuspendRequest { + pub suspend: u32, +} +impl SuspendRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let suspend_bytes = self.suspend.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SUSPEND_REQUEST, + 0, + 0, + suspend_bytes[0], + suspend_bytes[1], + suspend_bytes[2], + suspend_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn suspend(conn: &Conn, suspend: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let suspend_bytes = suspend.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SUSPEND_REQUEST, - 0, - 0, - suspend_bytes[0], - suspend_bytes[1], - suspend_bytes[2], - suspend_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SuspendRequest { + suspend, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Notify event @@ -808,7 +938,7 @@ pub trait ConnectionExt: RequestConnection { { select_input(self, drawable, event_mask) } - fn screensaver_set_attributes<'c>(&'c self, drawable: xproto::Drawable, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: xproto::WindowClass, depth: u8, visual: xproto::Visualid, value_list: &SetAttributesAux) -> Result, ConnectionError> + fn screensaver_set_attributes<'c, 'input>(&'c self, drawable: xproto::Drawable, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: xproto::WindowClass, depth: u8, visual: xproto::Visualid, value_list: &'input SetAttributesAux) -> Result, ConnectionError> { set_attributes(self, drawable, x, y, width, height, border_width, class, depth, visual, value_list) } diff --git a/src/protocol/shape.rs b/src/protocol/shape.rs index 59ad9018..e0b90015 100644 --- a/src/protocol/shape.rs +++ b/src/protocol/shape.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -268,24 +268,38 @@ impl From for [u8; 32] { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest; +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -317,202 +331,332 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the Rectangles request pub const RECTANGLES_REQUEST: u8 = 1; -pub fn rectangles<'c, Conn>(conn: &'c Conn, operation: SO, destination_kind: SK, ordering: xproto::ClipOrdering, destination_window: xproto::Window, x_offset: i16, y_offset: i16, rectangles: &[xproto::Rectangle]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RectanglesRequest<'input> { + pub operation: SO, + pub destination_kind: SK, + pub ordering: xproto::ClipOrdering, + pub destination_window: xproto::Window, + pub x_offset: i16, + pub y_offset: i16, + pub rectangles: &'input [xproto::Rectangle], +} +impl<'input> RectanglesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let operation_bytes = Op::from(self.operation).serialize(); + let destination_kind_bytes = Kind::from(self.destination_kind).serialize(); + let ordering_bytes = u8::from(self.ordering).serialize(); + let destination_window_bytes = self.destination_window.serialize(); + let x_offset_bytes = self.x_offset.serialize(); + let y_offset_bytes = self.y_offset.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + RECTANGLES_REQUEST, + 0, + 0, + operation_bytes[0], + destination_kind_bytes[0], + ordering_bytes[0], + 0, + destination_window_bytes[0], + destination_window_bytes[1], + destination_window_bytes[2], + destination_window_bytes[3], + x_offset_bytes[0], + x_offset_bytes[1], + y_offset_bytes[0], + y_offset_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let rectangles_bytes = self.rectangles.serialize(); + let length_so_far = length_so_far + rectangles_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), rectangles_bytes.into(), padding0.into()], vec![])) + } +} +pub fn rectangles<'c, 'input, Conn>(conn: &'c Conn, operation: SO, destination_kind: SK, ordering: xproto::ClipOrdering, destination_window: xproto::Window, x_offset: i16, y_offset: i16, rectangles: &'input [xproto::Rectangle]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let operation_bytes = Op::from(operation).serialize(); - let destination_kind_bytes = Kind::from(destination_kind).serialize(); - let ordering_bytes = u8::from(ordering).serialize(); - let destination_window_bytes = destination_window.serialize(); - let x_offset_bytes = x_offset.serialize(); - let y_offset_bytes = y_offset.serialize(); - let mut request0 = [ - extension_information.major_opcode, - RECTANGLES_REQUEST, - 0, - 0, - operation_bytes[0], - destination_kind_bytes[0], - ordering_bytes[0], - 0, - destination_window_bytes[0], - destination_window_bytes[1], - destination_window_bytes[2], - destination_window_bytes[3], - x_offset_bytes[0], - x_offset_bytes[1], - y_offset_bytes[0], - y_offset_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let rectangles_bytes = rectangles.serialize(); - let length_so_far = length_so_far + rectangles_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&rectangles_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = RectanglesRequest { + operation, + destination_kind, + ordering, + destination_window, + x_offset, + y_offset, + rectangles, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Mask request pub const MASK_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct MaskRequest { + pub operation: SO, + pub destination_kind: SK, + pub destination_window: xproto::Window, + pub x_offset: i16, + pub y_offset: i16, + pub source_bitmap: xproto::Pixmap, +} +impl MaskRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let operation_bytes = Op::from(self.operation).serialize(); + let destination_kind_bytes = Kind::from(self.destination_kind).serialize(); + let destination_window_bytes = self.destination_window.serialize(); + let x_offset_bytes = self.x_offset.serialize(); + let y_offset_bytes = self.y_offset.serialize(); + let source_bitmap_bytes = self.source_bitmap.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + MASK_REQUEST, + 0, + 0, + operation_bytes[0], + destination_kind_bytes[0], + 0, + 0, + destination_window_bytes[0], + destination_window_bytes[1], + destination_window_bytes[2], + destination_window_bytes[3], + x_offset_bytes[0], + x_offset_bytes[1], + y_offset_bytes[0], + y_offset_bytes[1], + source_bitmap_bytes[0], + source_bitmap_bytes[1], + source_bitmap_bytes[2], + source_bitmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn mask(conn: &Conn, operation: SO, destination_kind: SK, destination_window: xproto::Window, x_offset: i16, y_offset: i16, source_bitmap: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let source_bitmap: xproto::Pixmap = source_bitmap.into(); - let length_so_far = 0; - let operation_bytes = Op::from(operation).serialize(); - let destination_kind_bytes = Kind::from(destination_kind).serialize(); - let destination_window_bytes = destination_window.serialize(); - let x_offset_bytes = x_offset.serialize(); - let y_offset_bytes = y_offset.serialize(); - let source_bitmap_bytes = source_bitmap.serialize(); - let mut request0 = [ - extension_information.major_opcode, - MASK_REQUEST, - 0, - 0, - operation_bytes[0], - destination_kind_bytes[0], - 0, - 0, - destination_window_bytes[0], - destination_window_bytes[1], - destination_window_bytes[2], - destination_window_bytes[3], - x_offset_bytes[0], - x_offset_bytes[1], - y_offset_bytes[0], - y_offset_bytes[1], - source_bitmap_bytes[0], - source_bitmap_bytes[1], - source_bitmap_bytes[2], - source_bitmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = MaskRequest { + operation, + destination_kind, + destination_window, + x_offset, + y_offset, + source_bitmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Combine request pub const COMBINE_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CombineRequest { + pub operation: SO, + pub destination_kind: SK, + pub source_kind: SK, + pub destination_window: xproto::Window, + pub x_offset: i16, + pub y_offset: i16, + pub source_window: xproto::Window, +} +impl CombineRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let operation_bytes = Op::from(self.operation).serialize(); + let destination_kind_bytes = Kind::from(self.destination_kind).serialize(); + let source_kind_bytes = Kind::from(self.source_kind).serialize(); + let destination_window_bytes = self.destination_window.serialize(); + let x_offset_bytes = self.x_offset.serialize(); + let y_offset_bytes = self.y_offset.serialize(); + let source_window_bytes = self.source_window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + COMBINE_REQUEST, + 0, + 0, + operation_bytes[0], + destination_kind_bytes[0], + source_kind_bytes[0], + 0, + destination_window_bytes[0], + destination_window_bytes[1], + destination_window_bytes[2], + destination_window_bytes[3], + x_offset_bytes[0], + x_offset_bytes[1], + y_offset_bytes[0], + y_offset_bytes[1], + source_window_bytes[0], + source_window_bytes[1], + source_window_bytes[2], + source_window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn combine(conn: &Conn, operation: SO, destination_kind: SK, source_kind: SK, destination_window: xproto::Window, x_offset: i16, y_offset: i16, source_window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let operation_bytes = Op::from(operation).serialize(); - let destination_kind_bytes = Kind::from(destination_kind).serialize(); - let source_kind_bytes = Kind::from(source_kind).serialize(); - let destination_window_bytes = destination_window.serialize(); - let x_offset_bytes = x_offset.serialize(); - let y_offset_bytes = y_offset.serialize(); - let source_window_bytes = source_window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - COMBINE_REQUEST, - 0, - 0, - operation_bytes[0], - destination_kind_bytes[0], - source_kind_bytes[0], - 0, - destination_window_bytes[0], - destination_window_bytes[1], - destination_window_bytes[2], - destination_window_bytes[3], - x_offset_bytes[0], - x_offset_bytes[1], - y_offset_bytes[0], - y_offset_bytes[1], - source_window_bytes[0], - source_window_bytes[1], - source_window_bytes[2], - source_window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CombineRequest { + operation, + destination_kind, + source_kind, + destination_window, + x_offset, + y_offset, + source_window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Offset request pub const OFFSET_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct OffsetRequest { + pub destination_kind: SK, + pub destination_window: xproto::Window, + pub x_offset: i16, + pub y_offset: i16, +} +impl OffsetRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let destination_kind_bytes = Kind::from(self.destination_kind).serialize(); + let destination_window_bytes = self.destination_window.serialize(); + let x_offset_bytes = self.x_offset.serialize(); + let y_offset_bytes = self.y_offset.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + OFFSET_REQUEST, + 0, + 0, + destination_kind_bytes[0], + 0, + 0, + 0, + destination_window_bytes[0], + destination_window_bytes[1], + destination_window_bytes[2], + destination_window_bytes[3], + x_offset_bytes[0], + x_offset_bytes[1], + y_offset_bytes[0], + y_offset_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn offset(conn: &Conn, destination_kind: SK, destination_window: xproto::Window, x_offset: i16, y_offset: i16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let destination_kind_bytes = Kind::from(destination_kind).serialize(); - let destination_window_bytes = destination_window.serialize(); - let x_offset_bytes = x_offset.serialize(); - let y_offset_bytes = y_offset.serialize(); - let mut request0 = [ - extension_information.major_opcode, - OFFSET_REQUEST, - 0, - 0, - destination_kind_bytes[0], - 0, - 0, - 0, - destination_window_bytes[0], - destination_window_bytes[1], - destination_window_bytes[2], - destination_window_bytes[3], - x_offset_bytes[0], - x_offset_bytes[1], - y_offset_bytes[0], - y_offset_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = OffsetRequest { + destination_kind, + destination_window, + x_offset, + y_offset, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the QueryExtents request pub const QUERY_EXTENTS_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryExtentsRequest { + pub destination_window: xproto::Window, +} +impl QueryExtentsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let destination_window_bytes = self.destination_window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_EXTENTS_REQUEST, + 0, + 0, + destination_window_bytes[0], + destination_window_bytes[1], + destination_window_bytes[2], + destination_window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_extents(conn: &Conn, destination_window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let destination_window_bytes = destination_window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_EXTENTS_REQUEST, - 0, - 0, - destination_window_bytes[0], - destination_window_bytes[1], - destination_window_bytes[2], - destination_window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryExtentsRequest { + destination_window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -561,61 +705,99 @@ impl TryFrom<&[u8]> for QueryExtentsReply { /// Opcode for the SelectInput request pub const SELECT_INPUT_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectInputRequest { + pub destination_window: xproto::Window, + pub enable: bool, +} +impl SelectInputRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let destination_window_bytes = self.destination_window.serialize(); + let enable_bytes = self.enable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_INPUT_REQUEST, + 0, + 0, + destination_window_bytes[0], + destination_window_bytes[1], + destination_window_bytes[2], + destination_window_bytes[3], + enable_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn select_input(conn: &Conn, destination_window: xproto::Window, enable: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let destination_window_bytes = destination_window.serialize(); - let enable_bytes = enable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_INPUT_REQUEST, - 0, - 0, - destination_window_bytes[0], - destination_window_bytes[1], - destination_window_bytes[2], - destination_window_bytes[3], - enable_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SelectInputRequest { + destination_window, + enable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the InputSelected request pub const INPUT_SELECTED_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct InputSelectedRequest { + pub destination_window: xproto::Window, +} +impl InputSelectedRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let destination_window_bytes = self.destination_window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + INPUT_SELECTED_REQUEST, + 0, + 0, + destination_window_bytes[0], + destination_window_bytes[1], + destination_window_bytes[2], + destination_window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn input_selected(conn: &Conn, destination_window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let destination_window_bytes = destination_window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - INPUT_SELECTED_REQUEST, - 0, - 0, - destination_window_bytes[0], - destination_window_bytes[1], - destination_window_bytes[2], - destination_window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = InputSelectedRequest { + destination_window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -644,34 +826,54 @@ impl TryFrom<&[u8]> for InputSelectedReply { /// Opcode for the GetRectangles request pub const GET_RECTANGLES_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetRectanglesRequest { + pub window: xproto::Window, + pub source_kind: SK, +} +impl GetRectanglesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let source_kind_bytes = Kind::from(self.source_kind).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_RECTANGLES_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + source_kind_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_rectangles(conn: &Conn, window: xproto::Window, source_kind: SK) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let source_kind_bytes = Kind::from(source_kind).serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_RECTANGLES_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - source_kind_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetRectanglesRequest { + window, + source_kind, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -724,7 +926,7 @@ pub trait ConnectionExt: RequestConnection { { query_version(self) } - fn shape_rectangles<'c>(&'c self, operation: SO, destination_kind: SK, ordering: xproto::ClipOrdering, destination_window: xproto::Window, x_offset: i16, y_offset: i16, rectangles: &[xproto::Rectangle]) -> Result, ConnectionError> + fn shape_rectangles<'c, 'input>(&'c self, operation: SO, destination_kind: SK, ordering: xproto::ClipOrdering, destination_window: xproto::Window, x_offset: i16, y_offset: i16, rectangles: &'input [xproto::Rectangle]) -> Result, ConnectionError> { self::rectangles(self, operation, destination_kind, ordering, destination_window, x_offset, y_offset, rectangles) } diff --git a/src/protocol/shm.rs b/src/protocol/shm.rs index f6020b9c..cd21310a 100644 --- a/src/protocol/shm.rs +++ b/src/protocol/shm.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -126,24 +126,38 @@ pub type BadSegError = xproto::ValueError; /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest; +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -183,198 +197,318 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the Attach request pub const ATTACH_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AttachRequest { + pub shmseg: Seg, + pub shmid: u32, + pub read_only: bool, +} +impl AttachRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let shmseg_bytes = self.shmseg.serialize(); + let shmid_bytes = self.shmid.serialize(); + let read_only_bytes = self.read_only.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + ATTACH_REQUEST, + 0, + 0, + shmseg_bytes[0], + shmseg_bytes[1], + shmseg_bytes[2], + shmseg_bytes[3], + shmid_bytes[0], + shmid_bytes[1], + shmid_bytes[2], + shmid_bytes[3], + read_only_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn attach(conn: &Conn, shmseg: Seg, shmid: u32, read_only: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let shmseg_bytes = shmseg.serialize(); - let shmid_bytes = shmid.serialize(); - let read_only_bytes = read_only.serialize(); - let mut request0 = [ - extension_information.major_opcode, - ATTACH_REQUEST, - 0, - 0, - shmseg_bytes[0], - shmseg_bytes[1], - shmseg_bytes[2], - shmseg_bytes[3], - shmid_bytes[0], - shmid_bytes[1], - shmid_bytes[2], - shmid_bytes[3], - read_only_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = AttachRequest { + shmseg, + shmid, + read_only, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Detach request pub const DETACH_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DetachRequest { + pub shmseg: Seg, +} +impl DetachRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let shmseg_bytes = self.shmseg.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DETACH_REQUEST, + 0, + 0, + shmseg_bytes[0], + shmseg_bytes[1], + shmseg_bytes[2], + shmseg_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn detach(conn: &Conn, shmseg: Seg) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let shmseg_bytes = shmseg.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DETACH_REQUEST, - 0, - 0, - shmseg_bytes[0], - shmseg_bytes[1], - shmseg_bytes[2], - shmseg_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DetachRequest { + shmseg, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PutImage request pub const PUT_IMAGE_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PutImageRequest { + pub drawable: xproto::Drawable, + pub gc: xproto::Gcontext, + pub total_width: u16, + pub total_height: u16, + pub src_x: u16, + pub src_y: u16, + pub src_width: u16, + pub src_height: u16, + pub dst_x: i16, + pub dst_y: i16, + pub depth: u8, + pub format: u8, + pub send_event: bool, + pub shmseg: Seg, + pub offset: u32, +} +impl PutImageRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let total_width_bytes = self.total_width.serialize(); + let total_height_bytes = self.total_height.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let src_width_bytes = self.src_width.serialize(); + let src_height_bytes = self.src_height.serialize(); + let dst_x_bytes = self.dst_x.serialize(); + let dst_y_bytes = self.dst_y.serialize(); + let depth_bytes = self.depth.serialize(); + let format_bytes = self.format.serialize(); + let send_event_bytes = self.send_event.serialize(); + let shmseg_bytes = self.shmseg.serialize(); + let offset_bytes = self.offset.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PUT_IMAGE_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + total_width_bytes[0], + total_width_bytes[1], + total_height_bytes[0], + total_height_bytes[1], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + src_width_bytes[0], + src_width_bytes[1], + src_height_bytes[0], + src_height_bytes[1], + dst_x_bytes[0], + dst_x_bytes[1], + dst_y_bytes[0], + dst_y_bytes[1], + depth_bytes[0], + format_bytes[0], + send_event_bytes[0], + 0, + shmseg_bytes[0], + shmseg_bytes[1], + shmseg_bytes[2], + shmseg_bytes[3], + offset_bytes[0], + offset_bytes[1], + offset_bytes[2], + offset_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn put_image(conn: &Conn, drawable: xproto::Drawable, gc: xproto::Gcontext, total_width: u16, total_height: u16, src_x: u16, src_y: u16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16, depth: u8, format: u8, send_event: bool, shmseg: Seg, offset: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let total_width_bytes = total_width.serialize(); - let total_height_bytes = total_height.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let src_width_bytes = src_width.serialize(); - let src_height_bytes = src_height.serialize(); - let dst_x_bytes = dst_x.serialize(); - let dst_y_bytes = dst_y.serialize(); - let depth_bytes = depth.serialize(); - let format_bytes = format.serialize(); - let send_event_bytes = send_event.serialize(); - let shmseg_bytes = shmseg.serialize(); - let offset_bytes = offset.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PUT_IMAGE_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - total_width_bytes[0], - total_width_bytes[1], - total_height_bytes[0], - total_height_bytes[1], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - src_width_bytes[0], - src_width_bytes[1], - src_height_bytes[0], - src_height_bytes[1], - dst_x_bytes[0], - dst_x_bytes[1], - dst_y_bytes[0], - dst_y_bytes[1], - depth_bytes[0], - format_bytes[0], - send_event_bytes[0], - 0, - shmseg_bytes[0], - shmseg_bytes[1], - shmseg_bytes[2], - shmseg_bytes[3], - offset_bytes[0], - offset_bytes[1], - offset_bytes[2], - offset_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PutImageRequest { + drawable, + gc, + total_width, + total_height, + src_x, + src_y, + src_width, + src_height, + dst_x, + dst_y, + depth, + format, + send_event, + shmseg, + offset, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetImage request pub const GET_IMAGE_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetImageRequest { + pub drawable: xproto::Drawable, + pub x: i16, + pub y: i16, + pub width: u16, + pub height: u16, + pub plane_mask: u32, + pub format: u8, + pub shmseg: Seg, + pub offset: u32, +} +impl GetImageRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let plane_mask_bytes = self.plane_mask.serialize(); + let format_bytes = self.format.serialize(); + let shmseg_bytes = self.shmseg.serialize(); + let offset_bytes = self.offset.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_IMAGE_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + plane_mask_bytes[0], + plane_mask_bytes[1], + plane_mask_bytes[2], + plane_mask_bytes[3], + format_bytes[0], + 0, + 0, + 0, + shmseg_bytes[0], + shmseg_bytes[1], + shmseg_bytes[2], + shmseg_bytes[3], + offset_bytes[0], + offset_bytes[1], + offset_bytes[2], + offset_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_image(conn: &Conn, drawable: xproto::Drawable, x: i16, y: i16, width: u16, height: u16, plane_mask: u32, format: u8, shmseg: Seg, offset: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let plane_mask_bytes = plane_mask.serialize(); - let format_bytes = format.serialize(); - let shmseg_bytes = shmseg.serialize(); - let offset_bytes = offset.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_IMAGE_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - plane_mask_bytes[0], - plane_mask_bytes[1], - plane_mask_bytes[2], - plane_mask_bytes[3], - format_bytes[0], - 0, - 0, - 0, - shmseg_bytes[0], - shmseg_bytes[1], - shmseg_bytes[2], - shmseg_bytes[3], - offset_bytes[0], - offset_bytes[1], - offset_bytes[2], - offset_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetImageRequest { + drawable, + x, + y, + width, + height, + plane_mask, + format, + shmseg, + offset, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -407,126 +541,200 @@ impl TryFrom<&[u8]> for GetImageReply { /// Opcode for the CreatePixmap request pub const CREATE_PIXMAP_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreatePixmapRequest { + pub pid: xproto::Pixmap, + pub drawable: xproto::Drawable, + pub width: u16, + pub height: u16, + pub depth: u8, + pub shmseg: Seg, + pub offset: u32, +} +impl CreatePixmapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let pid_bytes = self.pid.serialize(); + let drawable_bytes = self.drawable.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let depth_bytes = self.depth.serialize(); + let shmseg_bytes = self.shmseg.serialize(); + let offset_bytes = self.offset.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_PIXMAP_REQUEST, + 0, + 0, + pid_bytes[0], + pid_bytes[1], + pid_bytes[2], + pid_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + depth_bytes[0], + 0, + 0, + 0, + shmseg_bytes[0], + shmseg_bytes[1], + shmseg_bytes[2], + shmseg_bytes[3], + offset_bytes[0], + offset_bytes[1], + offset_bytes[2], + offset_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_pixmap(conn: &Conn, pid: xproto::Pixmap, drawable: xproto::Drawable, width: u16, height: u16, depth: u8, shmseg: Seg, offset: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let pid_bytes = pid.serialize(); - let drawable_bytes = drawable.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let depth_bytes = depth.serialize(); - let shmseg_bytes = shmseg.serialize(); - let offset_bytes = offset.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_PIXMAP_REQUEST, - 0, - 0, - pid_bytes[0], - pid_bytes[1], - pid_bytes[2], - pid_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - depth_bytes[0], - 0, - 0, - 0, - shmseg_bytes[0], - shmseg_bytes[1], - shmseg_bytes[2], - shmseg_bytes[3], - offset_bytes[0], - offset_bytes[1], - offset_bytes[2], - offset_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreatePixmapRequest { + pid, + drawable, + width, + height, + depth, + shmseg, + offset, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the AttachFd request pub const ATTACH_FD_REQUEST: u8 = 6; +#[derive(Debug, PartialEq, Eq)] +pub struct AttachFdRequest { + pub shmseg: Seg, + pub shm_fd: RawFdContainer, + pub read_only: bool, +} +impl AttachFdRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let shmseg_bytes = self.shmseg.serialize(); + let read_only_bytes = self.read_only.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + ATTACH_FD_REQUEST, + 0, + 0, + shmseg_bytes[0], + shmseg_bytes[1], + shmseg_bytes[2], + shmseg_bytes[3], + read_only_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![self.shm_fd])) + } +} pub fn attach_fd(conn: &Conn, shmseg: Seg, shm_fd: A, read_only: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let shm_fd: RawFdContainer = shm_fd.into(); - let length_so_far = 0; - let shmseg_bytes = shmseg.serialize(); - let read_only_bytes = read_only.serialize(); - let mut request0 = [ - extension_information.major_opcode, - ATTACH_FD_REQUEST, - 0, - 0, - shmseg_bytes[0], - shmseg_bytes[1], - shmseg_bytes[2], - shmseg_bytes[3], - read_only_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![shm_fd])?) + let request0 = AttachFdRequest { + shmseg, + shm_fd, + read_only, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateSegment request pub const CREATE_SEGMENT_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateSegmentRequest { + pub shmseg: Seg, + pub size: u32, + pub read_only: bool, +} +impl CreateSegmentRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let shmseg_bytes = self.shmseg.serialize(); + let size_bytes = self.size.serialize(); + let read_only_bytes = self.read_only.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_SEGMENT_REQUEST, + 0, + 0, + shmseg_bytes[0], + shmseg_bytes[1], + shmseg_bytes[2], + shmseg_bytes[3], + size_bytes[0], + size_bytes[1], + size_bytes[2], + size_bytes[3], + read_only_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_segment(conn: &Conn, shmseg: Seg, size: u32, read_only: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let shmseg_bytes = shmseg.serialize(); - let size_bytes = size.serialize(); - let read_only_bytes = read_only.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_SEGMENT_REQUEST, - 0, - 0, - shmseg_bytes[0], - shmseg_bytes[1], - shmseg_bytes[2], - shmseg_bytes[3], - size_bytes[0], - size_bytes[1], - size_bytes[2], - size_bytes[3], - read_only_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply_with_fds(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateSegmentRequest { + shmseg, + size, + read_only, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply_with_fds(&slices, fds)?) } #[derive(Debug, PartialEq, Eq)] diff --git a/src/protocol/sync.rs b/src/protocol/sync.rs index a73cfd58..66001deb 100644 --- a/src/protocol/sync.rs +++ b/src/protocol/sync.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -708,30 +708,50 @@ impl From for [u8; 32] { /// Opcode for the Initialize request pub const INITIALIZE_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct InitializeRequest { + pub desired_major_version: u8, + pub desired_minor_version: u8, +} +impl InitializeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let desired_major_version_bytes = self.desired_major_version.serialize(); + let desired_minor_version_bytes = self.desired_minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + INITIALIZE_REQUEST, + 0, + 0, + desired_major_version_bytes[0], + desired_minor_version_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn initialize(conn: &Conn, desired_major_version: u8, desired_minor_version: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let desired_major_version_bytes = desired_major_version.serialize(); - let desired_minor_version_bytes = desired_minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - INITIALIZE_REQUEST, - 0, - 0, - desired_major_version_bytes[0], - desired_minor_version_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = InitializeRequest { + desired_major_version, + desired_minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -764,24 +784,38 @@ impl TryFrom<&[u8]> for InitializeReply { /// Opcode for the ListSystemCounters request pub const LIST_SYSTEM_COUNTERS_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListSystemCountersRequest; +impl ListSystemCountersRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + LIST_SYSTEM_COUNTERS_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_system_counters(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - LIST_SYSTEM_COUNTERS_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListSystemCountersRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -828,92 +862,148 @@ impl ListSystemCountersReply { /// Opcode for the CreateCounter request pub const CREATE_COUNTER_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateCounterRequest { + pub id: Counter, + pub initial_value: Int64, +} +impl CreateCounterRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let id_bytes = self.id.serialize(); + let initial_value_bytes = self.initial_value.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_COUNTER_REQUEST, + 0, + 0, + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + initial_value_bytes[0], + initial_value_bytes[1], + initial_value_bytes[2], + initial_value_bytes[3], + initial_value_bytes[4], + initial_value_bytes[5], + initial_value_bytes[6], + initial_value_bytes[7], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_counter(conn: &Conn, id: Counter, initial_value: Int64) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let id_bytes = id.serialize(); - let initial_value_bytes = initial_value.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_COUNTER_REQUEST, - 0, - 0, - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - initial_value_bytes[0], - initial_value_bytes[1], - initial_value_bytes[2], - initial_value_bytes[3], - initial_value_bytes[4], - initial_value_bytes[5], - initial_value_bytes[6], - initial_value_bytes[7], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateCounterRequest { + id, + initial_value, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DestroyCounter request pub const DESTROY_COUNTER_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyCounterRequest { + pub counter: Counter, +} +impl DestroyCounterRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let counter_bytes = self.counter.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_COUNTER_REQUEST, + 0, + 0, + counter_bytes[0], + counter_bytes[1], + counter_bytes[2], + counter_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_counter(conn: &Conn, counter: Counter) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let counter_bytes = counter.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_COUNTER_REQUEST, - 0, - 0, - counter_bytes[0], - counter_bytes[1], - counter_bytes[2], - counter_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyCounterRequest { + counter, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the QueryCounter request pub const QUERY_COUNTER_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryCounterRequest { + pub counter: Counter, +} +impl QueryCounterRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let counter_bytes = self.counter.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_COUNTER_REQUEST, + 0, + 0, + counter_bytes[0], + counter_bytes[1], + counter_bytes[2], + counter_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_counter(conn: &Conn, counter: Counter) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let counter_bytes = counter.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_COUNTER_REQUEST, - 0, - 0, - counter_bytes[0], - counter_bytes[1], - counter_bytes[2], - counter_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryCounterRequest { + counter, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -943,104 +1033,160 @@ impl TryFrom<&[u8]> for QueryCounterReply { /// Opcode for the Await request pub const AWAIT_REQUEST: u8 = 7; -pub fn await_<'c, Conn>(conn: &'c Conn, wait_list: &[Waitcondition]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AwaitRequest<'input> { + pub wait_list: &'input [Waitcondition], +} +impl<'input> AwaitRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + AWAIT_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let wait_list_bytes = self.wait_list.serialize(); + let length_so_far = length_so_far + wait_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), wait_list_bytes.into(), padding0.into()], vec![])) + } +} +pub fn await_<'c, 'input, Conn>(conn: &'c Conn, wait_list: &'input [Waitcondition]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - AWAIT_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let wait_list_bytes = wait_list.serialize(); - let length_so_far = length_so_far + wait_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&wait_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = AwaitRequest { + wait_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ChangeCounter request pub const CHANGE_COUNTER_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangeCounterRequest { + pub counter: Counter, + pub amount: Int64, +} +impl ChangeCounterRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let counter_bytes = self.counter.serialize(); + let amount_bytes = self.amount.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_COUNTER_REQUEST, + 0, + 0, + counter_bytes[0], + counter_bytes[1], + counter_bytes[2], + counter_bytes[3], + amount_bytes[0], + amount_bytes[1], + amount_bytes[2], + amount_bytes[3], + amount_bytes[4], + amount_bytes[5], + amount_bytes[6], + amount_bytes[7], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn change_counter(conn: &Conn, counter: Counter, amount: Int64) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let counter_bytes = counter.serialize(); - let amount_bytes = amount.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_COUNTER_REQUEST, - 0, - 0, - counter_bytes[0], - counter_bytes[1], - counter_bytes[2], - counter_bytes[3], - amount_bytes[0], - amount_bytes[1], - amount_bytes[2], - amount_bytes[3], - amount_bytes[4], - amount_bytes[5], - amount_bytes[6], - amount_bytes[7], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ChangeCounterRequest { + counter, + amount, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetCounter request pub const SET_COUNTER_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetCounterRequest { + pub counter: Counter, + pub value: Int64, +} +impl SetCounterRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let counter_bytes = self.counter.serialize(); + let value_bytes = self.value.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_COUNTER_REQUEST, + 0, + 0, + counter_bytes[0], + counter_bytes[1], + counter_bytes[2], + counter_bytes[3], + value_bytes[0], + value_bytes[1], + value_bytes[2], + value_bytes[3], + value_bytes[4], + value_bytes[5], + value_bytes[6], + value_bytes[7], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_counter(conn: &Conn, counter: Counter, value: Int64) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let counter_bytes = counter.serialize(); - let value_bytes = value.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_COUNTER_REQUEST, - 0, - 0, - counter_bytes[0], - counter_bytes[1], - counter_bytes[2], - counter_bytes[3], - value_bytes[0], - value_bytes[1], - value_bytes[2], - value_bytes[3], - value_bytes[4], - value_bytes[5], - value_bytes[6], - value_bytes[7], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetCounterRequest { + counter, + value, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } -/// Opcode for the CreateAlarm request -pub const CREATE_ALARM_REQUEST: u8 = 8; /// Auxiliary and optional information for the `create_alarm` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct CreateAlarmAux { @@ -1140,43 +1286,63 @@ impl CreateAlarmAux { } } -pub fn create_alarm<'c, Conn>(conn: &'c Conn, id: Alarm, value_list: &CreateAlarmAux) -> Result, ConnectionError> +/// Opcode for the CreateAlarm request +pub const CREATE_ALARM_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateAlarmRequest<'input> { + pub id: Alarm, + pub value_list: &'input CreateAlarmAux, +} +impl<'input> CreateAlarmRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let id_bytes = self.id.serialize(); + let value_mask = u32::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_ALARM_REQUEST, + 0, + 0, + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_alarm<'c, 'input, Conn>(conn: &'c Conn, id: Alarm, value_list: &'input CreateAlarmAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let id_bytes = id.serialize(); - let value_mask = u32::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_ALARM_REQUEST, - 0, - 0, - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateAlarmRequest { + id, + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } -/// Opcode for the ChangeAlarm request -pub const CHANGE_ALARM_REQUEST: u8 = 9; /// Auxiliary and optional information for the `change_alarm` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct ChangeAlarmAux { @@ -1276,93 +1442,151 @@ impl ChangeAlarmAux { } } -pub fn change_alarm<'c, Conn>(conn: &'c Conn, id: Alarm, value_list: &ChangeAlarmAux) -> Result, ConnectionError> +/// Opcode for the ChangeAlarm request +pub const CHANGE_ALARM_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangeAlarmRequest<'input> { + pub id: Alarm, + pub value_list: &'input ChangeAlarmAux, +} +impl<'input> ChangeAlarmRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let id_bytes = self.id.serialize(); + let value_mask = u32::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_ALARM_REQUEST, + 0, + 0, + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) + } +} +pub fn change_alarm<'c, 'input, Conn>(conn: &'c Conn, id: Alarm, value_list: &'input ChangeAlarmAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let id_bytes = id.serialize(); - let value_mask = u32::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_ALARM_REQUEST, - 0, - 0, - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeAlarmRequest { + id, + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DestroyAlarm request pub const DESTROY_ALARM_REQUEST: u8 = 11; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyAlarmRequest { + pub alarm: Alarm, +} +impl DestroyAlarmRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let alarm_bytes = self.alarm.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_ALARM_REQUEST, + 0, + 0, + alarm_bytes[0], + alarm_bytes[1], + alarm_bytes[2], + alarm_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_alarm(conn: &Conn, alarm: Alarm) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let alarm_bytes = alarm.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_ALARM_REQUEST, - 0, - 0, - alarm_bytes[0], - alarm_bytes[1], - alarm_bytes[2], - alarm_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyAlarmRequest { + alarm, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the QueryAlarm request pub const QUERY_ALARM_REQUEST: u8 = 10; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryAlarmRequest { + pub alarm: Alarm, +} +impl QueryAlarmRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let alarm_bytes = self.alarm.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_ALARM_REQUEST, + 0, + 0, + alarm_bytes[0], + alarm_bytes[1], + alarm_bytes[2], + alarm_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_alarm(conn: &Conn, alarm: Alarm) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let alarm_bytes = alarm.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_ALARM_REQUEST, - 0, - 0, - alarm_bytes[0], - alarm_bytes[1], - alarm_bytes[2], - alarm_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryAlarmRequest { + alarm, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1400,61 +1624,99 @@ impl TryFrom<&[u8]> for QueryAlarmReply { /// Opcode for the SetPriority request pub const SET_PRIORITY_REQUEST: u8 = 12; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetPriorityRequest { + pub id: u32, + pub priority: i32, +} +impl SetPriorityRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let id_bytes = self.id.serialize(); + let priority_bytes = self.priority.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PRIORITY_REQUEST, + 0, + 0, + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + priority_bytes[0], + priority_bytes[1], + priority_bytes[2], + priority_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_priority(conn: &Conn, id: u32, priority: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let id_bytes = id.serialize(); - let priority_bytes = priority.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PRIORITY_REQUEST, - 0, - 0, - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - priority_bytes[0], - priority_bytes[1], - priority_bytes[2], - priority_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetPriorityRequest { + id, + priority, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetPriority request pub const GET_PRIORITY_REQUEST: u8 = 13; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPriorityRequest { + pub id: u32, +} +impl GetPriorityRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let id_bytes = self.id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PRIORITY_REQUEST, + 0, + 0, + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_priority(conn: &Conn, id: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let id_bytes = id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PRIORITY_REQUEST, - 0, - 0, - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPriorityRequest { + id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1484,147 +1746,241 @@ impl TryFrom<&[u8]> for GetPriorityReply { /// Opcode for the CreateFence request pub const CREATE_FENCE_REQUEST: u8 = 14; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateFenceRequest { + pub drawable: xproto::Drawable, + pub fence: Fence, + pub initially_triggered: bool, +} +impl CreateFenceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let fence_bytes = self.fence.serialize(); + let initially_triggered_bytes = self.initially_triggered.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_FENCE_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + fence_bytes[0], + fence_bytes[1], + fence_bytes[2], + fence_bytes[3], + initially_triggered_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_fence(conn: &Conn, drawable: xproto::Drawable, fence: Fence, initially_triggered: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let fence_bytes = fence.serialize(); - let initially_triggered_bytes = initially_triggered.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_FENCE_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - fence_bytes[0], - fence_bytes[1], - fence_bytes[2], - fence_bytes[3], - initially_triggered_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateFenceRequest { + drawable, + fence, + initially_triggered, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the TriggerFence request pub const TRIGGER_FENCE_REQUEST: u8 = 15; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct TriggerFenceRequest { + pub fence: Fence, +} +impl TriggerFenceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let fence_bytes = self.fence.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + TRIGGER_FENCE_REQUEST, + 0, + 0, + fence_bytes[0], + fence_bytes[1], + fence_bytes[2], + fence_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn trigger_fence(conn: &Conn, fence: Fence) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let fence_bytes = fence.serialize(); - let mut request0 = [ - extension_information.major_opcode, - TRIGGER_FENCE_REQUEST, - 0, - 0, - fence_bytes[0], - fence_bytes[1], - fence_bytes[2], - fence_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = TriggerFenceRequest { + fence, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ResetFence request pub const RESET_FENCE_REQUEST: u8 = 16; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ResetFenceRequest { + pub fence: Fence, +} +impl ResetFenceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let fence_bytes = self.fence.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + RESET_FENCE_REQUEST, + 0, + 0, + fence_bytes[0], + fence_bytes[1], + fence_bytes[2], + fence_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn reset_fence(conn: &Conn, fence: Fence) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let fence_bytes = fence.serialize(); - let mut request0 = [ - extension_information.major_opcode, - RESET_FENCE_REQUEST, - 0, - 0, - fence_bytes[0], - fence_bytes[1], - fence_bytes[2], - fence_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ResetFenceRequest { + fence, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DestroyFence request pub const DESTROY_FENCE_REQUEST: u8 = 17; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyFenceRequest { + pub fence: Fence, +} +impl DestroyFenceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let fence_bytes = self.fence.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_FENCE_REQUEST, + 0, + 0, + fence_bytes[0], + fence_bytes[1], + fence_bytes[2], + fence_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_fence(conn: &Conn, fence: Fence) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let fence_bytes = fence.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_FENCE_REQUEST, - 0, - 0, - fence_bytes[0], - fence_bytes[1], - fence_bytes[2], - fence_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyFenceRequest { + fence, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the QueryFence request pub const QUERY_FENCE_REQUEST: u8 = 18; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryFenceRequest { + pub fence: Fence, +} +impl QueryFenceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let fence_bytes = self.fence.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_FENCE_REQUEST, + 0, + 0, + fence_bytes[0], + fence_bytes[1], + fence_bytes[2], + fence_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_fence(conn: &Conn, fence: Fence) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let fence_bytes = fence.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_FENCE_REQUEST, - 0, - 0, - fence_bytes[0], - fence_bytes[1], - fence_bytes[2], - fence_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryFenceRequest { + fence, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1655,28 +2011,46 @@ impl TryFrom<&[u8]> for QueryFenceReply { /// Opcode for the AwaitFence request pub const AWAIT_FENCE_REQUEST: u8 = 19; -pub fn await_fence<'c, Conn>(conn: &'c Conn, fence_list: &[Fence]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AwaitFenceRequest<'input> { + pub fence_list: &'input [Fence], +} +impl<'input> AwaitFenceRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + AWAIT_FENCE_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let fence_list_bytes = self.fence_list.serialize(); + let length_so_far = length_so_far + fence_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), fence_list_bytes.into(), padding0.into()], vec![])) + } +} +pub fn await_fence<'c, 'input, Conn>(conn: &'c Conn, fence_list: &'input [Fence]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - AWAIT_FENCE_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let fence_list_bytes = fence_list.serialize(); - let length_so_far = length_so_far + fence_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&fence_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = AwaitFenceRequest { + fence_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CounterNotify event @@ -1877,7 +2251,7 @@ pub trait ConnectionExt: RequestConnection { { query_counter(self, counter) } - fn sync_await_<'c>(&'c self, wait_list: &[Waitcondition]) -> Result, ConnectionError> + fn sync_await_<'c, 'input>(&'c self, wait_list: &'input [Waitcondition]) -> Result, ConnectionError> { await_(self, wait_list) } @@ -1889,11 +2263,11 @@ pub trait ConnectionExt: RequestConnection { { set_counter(self, counter, value) } - fn sync_create_alarm<'c>(&'c self, id: Alarm, value_list: &CreateAlarmAux) -> Result, ConnectionError> + fn sync_create_alarm<'c, 'input>(&'c self, id: Alarm, value_list: &'input CreateAlarmAux) -> Result, ConnectionError> { create_alarm(self, id, value_list) } - fn sync_change_alarm<'c>(&'c self, id: Alarm, value_list: &ChangeAlarmAux) -> Result, ConnectionError> + fn sync_change_alarm<'c, 'input>(&'c self, id: Alarm, value_list: &'input ChangeAlarmAux) -> Result, ConnectionError> { change_alarm(self, id, value_list) } @@ -1933,7 +2307,7 @@ pub trait ConnectionExt: RequestConnection { { query_fence(self, fence) } - fn sync_await_fence<'c>(&'c self, fence_list: &[Fence]) -> Result, ConnectionError> + fn sync_await_fence<'c, 'input>(&'c self, fence_list: &'input [Fence]) -> Result, ConnectionError> { await_fence(self, fence_list) } diff --git a/src/protocol/xc_misc.rs b/src/protocol/xc_misc.rs index ed6fc57e..ea1bcec7 100644 --- a/src/protocol/xc_misc.rs +++ b/src/protocol/xc_misc.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -34,30 +34,50 @@ pub const X11_XML_VERSION: (u32, u32) = (1, 1); /// Opcode for the GetVersion request pub const GET_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetVersionRequest { + pub client_major_version: u16, + pub client_minor_version: u16, +} +impl GetVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_version_bytes = self.client_major_version.serialize(); + let client_minor_version_bytes = self.client_minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_VERSION_REQUEST, + 0, + 0, + client_major_version_bytes[0], + client_major_version_bytes[1], + client_minor_version_bytes[0], + client_minor_version_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_version(conn: &Conn, client_major_version: u16, client_minor_version: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_version_bytes = client_major_version.serialize(); - let client_minor_version_bytes = client_minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_VERSION_REQUEST, - 0, - 0, - client_major_version_bytes[0], - client_major_version_bytes[1], - client_minor_version_bytes[0], - client_minor_version_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetVersionRequest { + client_major_version, + client_minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -89,24 +109,38 @@ impl TryFrom<&[u8]> for GetVersionReply { /// Opcode for the GetXIDRange request pub const GET_XID_RANGE_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetXIDRangeRequest; +impl GetXIDRangeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + GET_XID_RANGE_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_xid_range(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - GET_XID_RANGE_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetXIDRangeRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -138,29 +172,47 @@ impl TryFrom<&[u8]> for GetXIDRangeReply { /// Opcode for the GetXIDList request pub const GET_XID_LIST_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetXIDListRequest { + pub count: u32, +} +impl GetXIDListRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let count_bytes = self.count.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_XID_LIST_REQUEST, + 0, + 0, + count_bytes[0], + count_bytes[1], + count_bytes[2], + count_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_xid_list(conn: &Conn, count: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let count_bytes = count.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_XID_LIST_REQUEST, - 0, - 0, - count_bytes[0], - count_bytes[1], - count_bytes[2], - count_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetXIDListRequest { + count, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/src/protocol/xevie.rs b/src/protocol/xevie.rs index 8dfe78d6..5618df6e 100644 --- a/src/protocol/xevie.rs +++ b/src/protocol/xevie.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -34,30 +34,50 @@ pub const X11_XML_VERSION: (u32, u32) = (1, 0); /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub client_major_version: u16, + pub client_minor_version: u16, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_version_bytes = self.client_major_version.serialize(); + let client_minor_version_bytes = self.client_minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + client_major_version_bytes[0], + client_major_version_bytes[1], + client_minor_version_bytes[0], + client_minor_version_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, client_major_version: u16, client_minor_version: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_version_bytes = client_major_version.serialize(); - let client_minor_version_bytes = client_minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - client_major_version_bytes[0], - client_major_version_bytes[1], - client_minor_version_bytes[0], - client_minor_version_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + client_major_version, + client_minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -90,29 +110,47 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the Start request pub const START_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct StartRequest { + pub screen: u32, +} +impl StartRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + START_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn start(conn: &Conn, screen: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - START_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = StartRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -141,29 +179,47 @@ impl TryFrom<&[u8]> for StartReply { /// Opcode for the End request pub const END_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct EndRequest { + pub cmap: u32, +} +impl EndRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let cmap_bytes = self.cmap.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + END_REQUEST, + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn end(conn: &Conn, cmap: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let cmap_bytes = cmap.serialize(); - let mut request0 = [ - extension_information.major_opcode, - END_REQUEST, - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = EndRequest { + cmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -322,126 +378,146 @@ impl Serialize for Event { /// Opcode for the Send request pub const SEND_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SendRequest { + pub event: Event, + pub data_type: u32, +} +impl SendRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let event_bytes = self.event.serialize(); + let data_type_bytes = self.data_type.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SEND_REQUEST, + 0, + 0, + event_bytes[0], + event_bytes[1], + event_bytes[2], + event_bytes[3], + event_bytes[4], + event_bytes[5], + event_bytes[6], + event_bytes[7], + event_bytes[8], + event_bytes[9], + event_bytes[10], + event_bytes[11], + event_bytes[12], + event_bytes[13], + event_bytes[14], + event_bytes[15], + event_bytes[16], + event_bytes[17], + event_bytes[18], + event_bytes[19], + event_bytes[20], + event_bytes[21], + event_bytes[22], + event_bytes[23], + event_bytes[24], + event_bytes[25], + event_bytes[26], + event_bytes[27], + event_bytes[28], + event_bytes[29], + event_bytes[30], + event_bytes[31], + data_type_bytes[0], + data_type_bytes[1], + data_type_bytes[2], + data_type_bytes[3], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn send(conn: &Conn, event: Event, data_type: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let event_bytes = event.serialize(); - let data_type_bytes = data_type.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SEND_REQUEST, - 0, - 0, - event_bytes[0], - event_bytes[1], - event_bytes[2], - event_bytes[3], - event_bytes[4], - event_bytes[5], - event_bytes[6], - event_bytes[7], - event_bytes[8], - event_bytes[9], - event_bytes[10], - event_bytes[11], - event_bytes[12], - event_bytes[13], - event_bytes[14], - event_bytes[15], - event_bytes[16], - event_bytes[17], - event_bytes[18], - event_bytes[19], - event_bytes[20], - event_bytes[21], - event_bytes[22], - event_bytes[23], - event_bytes[24], - event_bytes[25], - event_bytes[26], - event_bytes[27], - event_bytes[28], - event_bytes[29], - event_bytes[30], - event_bytes[31], - data_type_bytes[0], - data_type_bytes[1], - data_type_bytes[2], - data_type_bytes[3], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SendRequest { + event, + data_type, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -470,29 +546,47 @@ impl TryFrom<&[u8]> for SendReply { /// Opcode for the SelectInput request pub const SELECT_INPUT_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectInputRequest { + pub event_mask: u32, +} +impl SelectInputRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let event_mask_bytes = self.event_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_INPUT_REQUEST, + 0, + 0, + event_mask_bytes[0], + event_mask_bytes[1], + event_mask_bytes[2], + event_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn select_input(conn: &Conn, event_mask: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let event_mask_bytes = event_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_INPUT_REQUEST, - 0, - 0, - event_mask_bytes[0], - event_mask_bytes[1], - event_mask_bytes[2], - event_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SelectInputRequest { + event_mask, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] diff --git a/src/protocol/xf86dri.rs b/src/protocol/xf86dri.rs index 3475cda2..9eb1eb48 100644 --- a/src/protocol/xf86dri.rs +++ b/src/protocol/xf86dri.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -84,24 +84,38 @@ impl Serialize for DrmClipRect { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest; +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -135,29 +149,47 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the QueryDirectRenderingCapable request pub const QUERY_DIRECT_RENDERING_CAPABLE_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryDirectRenderingCapableRequest { + pub screen: u32, +} +impl QueryDirectRenderingCapableRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_DIRECT_RENDERING_CAPABLE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_direct_rendering_capable(conn: &Conn, screen: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_DIRECT_RENDERING_CAPABLE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryDirectRenderingCapableRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -187,29 +219,47 @@ impl TryFrom<&[u8]> for QueryDirectRenderingCapableReply { /// Opcode for the OpenConnection request pub const OPEN_CONNECTION_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct OpenConnectionRequest { + pub screen: u32, +} +impl OpenConnectionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + OPEN_CONNECTION_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn open_connection(conn: &Conn, screen: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - OPEN_CONNECTION_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = OpenConnectionRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -261,56 +311,92 @@ impl OpenConnectionReply { /// Opcode for the CloseConnection request pub const CLOSE_CONNECTION_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CloseConnectionRequest { + pub screen: u32, +} +impl CloseConnectionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CLOSE_CONNECTION_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn close_connection(conn: &Conn, screen: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CLOSE_CONNECTION_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CloseConnectionRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetClientDriverName request pub const GET_CLIENT_DRIVER_NAME_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetClientDriverNameRequest { + pub screen: u32, +} +impl GetClientDriverNameRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CLIENT_DRIVER_NAME_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_client_driver_name(conn: &Conn, screen: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CLIENT_DRIVER_NAME_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetClientDriverNameRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -364,39 +450,61 @@ impl GetClientDriverNameReply { /// Opcode for the CreateContext request pub const CREATE_CONTEXT_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateContextRequest { + pub screen: u32, + pub visual: u32, + pub context: u32, +} +impl CreateContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let visual_bytes = self.visual.serialize(); + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_CONTEXT_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + visual_bytes[0], + visual_bytes[1], + visual_bytes[2], + visual_bytes[3], + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_context(conn: &Conn, screen: u32, visual: u32, context: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let visual_bytes = visual.serialize(); - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_CONTEXT_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - visual_bytes[0], - visual_bytes[1], - visual_bytes[2], - visual_bytes[3], - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateContextRequest { + screen, + visual, + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -426,66 +534,106 @@ impl TryFrom<&[u8]> for CreateContextReply { /// Opcode for the DestroyContext request pub const DESTROY_CONTEXT_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyContextRequest { + pub screen: u32, + pub context: u32, +} +impl DestroyContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_CONTEXT_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_context(conn: &Conn, screen: u32, context: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_CONTEXT_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyContextRequest { + screen, + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateDrawable request pub const CREATE_DRAWABLE_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateDrawableRequest { + pub screen: u32, + pub drawable: u32, +} +impl CreateDrawableRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_DRAWABLE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_drawable(conn: &Conn, screen: u32, drawable: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_DRAWABLE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateDrawableRequest { + screen, + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -515,66 +663,106 @@ impl TryFrom<&[u8]> for CreateDrawableReply { /// Opcode for the DestroyDrawable request pub const DESTROY_DRAWABLE_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyDrawableRequest { + pub screen: u32, + pub drawable: u32, +} +impl DestroyDrawableRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_DRAWABLE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_drawable(conn: &Conn, screen: u32, drawable: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_DRAWABLE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyDrawableRequest { + screen, + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetDrawableInfo request pub const GET_DRAWABLE_INFO_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDrawableInfoRequest { + pub screen: u32, + pub drawable: u32, +} +impl GetDrawableInfoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DRAWABLE_INFO_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_drawable_info(conn: &Conn, screen: u32, drawable: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DRAWABLE_INFO_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDrawableInfoRequest { + screen, + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -652,29 +840,47 @@ impl GetDrawableInfoReply { /// Opcode for the GetDeviceInfo request pub const GET_DEVICE_INFO_REQUEST: u8 = 10; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceInfoRequest { + pub screen: u32, +} +impl GetDeviceInfoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_INFO_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_info(conn: &Conn, screen: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_INFO_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceInfoRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -730,34 +936,54 @@ impl GetDeviceInfoReply { /// Opcode for the AuthConnection request pub const AUTH_CONNECTION_REQUEST: u8 = 11; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AuthConnectionRequest { + pub screen: u32, + pub magic: u32, +} +impl AuthConnectionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let magic_bytes = self.magic.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + AUTH_CONNECTION_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + magic_bytes[0], + magic_bytes[1], + magic_bytes[2], + magic_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn auth_connection(conn: &Conn, screen: u32, magic: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let magic_bytes = magic.serialize(); - let mut request0 = [ - extension_information.major_opcode, - AUTH_CONNECTION_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - magic_bytes[0], - magic_bytes[1], - magic_bytes[2], - magic_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = AuthConnectionRequest { + screen, + magic, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] diff --git a/src/protocol/xf86vidmode.rs b/src/protocol/xf86vidmode.rs index a78b235b..773da6ae 100644 --- a/src/protocol/xf86vidmode.rs +++ b/src/protocol/xf86vidmode.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -367,24 +367,38 @@ impl Serialize for ModeInfo { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest; +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -416,29 +430,47 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the GetModeLine request pub const GET_MODE_LINE_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetModeLineRequest { + pub screen: u16, +} +impl GetModeLineRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MODE_LINE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_mode_line(conn: &Conn, screen: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MODE_LINE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetModeLineRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -509,141 +541,219 @@ impl GetModeLineReply { /// Opcode for the ModModeLine request pub const MOD_MODE_LINE_REQUEST: u8 = 2; -pub fn mod_mode_line<'c, Conn, A>(conn: &'c Conn, screen: u32, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ModModeLineRequest<'input> { + pub screen: u32, + pub hdisplay: u16, + pub hsyncstart: u16, + pub hsyncend: u16, + pub htotal: u16, + pub hskew: u16, + pub vdisplay: u16, + pub vsyncstart: u16, + pub vsyncend: u16, + pub vtotal: u16, + pub flags: u32, + pub private: &'input [u8], +} +impl<'input> ModModeLineRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let hdisplay_bytes = self.hdisplay.serialize(); + let hsyncstart_bytes = self.hsyncstart.serialize(); + let hsyncend_bytes = self.hsyncend.serialize(); + let htotal_bytes = self.htotal.serialize(); + let hskew_bytes = self.hskew.serialize(); + let vdisplay_bytes = self.vdisplay.serialize(); + let vsyncstart_bytes = self.vsyncstart.serialize(); + let vsyncend_bytes = self.vsyncend.serialize(); + let vtotal_bytes = self.vtotal.serialize(); + let flags_bytes = self.flags.serialize(); + let privsize = u32::try_from(self.private.len()).expect("`private` has too many elements"); + let privsize_bytes = privsize.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + MOD_MODE_LINE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + hdisplay_bytes[0], + hdisplay_bytes[1], + hsyncstart_bytes[0], + hsyncstart_bytes[1], + hsyncend_bytes[0], + hsyncend_bytes[1], + htotal_bytes[0], + htotal_bytes[1], + hskew_bytes[0], + hskew_bytes[1], + vdisplay_bytes[0], + vdisplay_bytes[1], + vsyncstart_bytes[0], + vsyncstart_bytes[1], + vsyncend_bytes[0], + vsyncend_bytes[1], + vtotal_bytes[0], + vtotal_bytes[1], + 0, + 0, + flags_bytes[0], + flags_bytes[1], + flags_bytes[2], + flags_bytes[3], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + privsize_bytes[0], + privsize_bytes[1], + privsize_bytes[2], + privsize_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.private[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.private[..]).into(), padding0.into()], vec![])) + } +} +pub fn mod_mode_line<'c, 'input, Conn, A>(conn: &'c Conn, screen: u32, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let flags: u32 = flags.into(); - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let hdisplay_bytes = hdisplay.serialize(); - let hsyncstart_bytes = hsyncstart.serialize(); - let hsyncend_bytes = hsyncend.serialize(); - let htotal_bytes = htotal.serialize(); - let hskew_bytes = hskew.serialize(); - let vdisplay_bytes = vdisplay.serialize(); - let vsyncstart_bytes = vsyncstart.serialize(); - let vsyncend_bytes = vsyncend.serialize(); - let vtotal_bytes = vtotal.serialize(); - let flags_bytes = flags.serialize(); - let privsize = u32::try_from(private.len()).expect("`private` has too many elements"); - let privsize_bytes = privsize.serialize(); - let mut request0 = [ - extension_information.major_opcode, - MOD_MODE_LINE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - hdisplay_bytes[0], - hdisplay_bytes[1], - hsyncstart_bytes[0], - hsyncstart_bytes[1], - hsyncend_bytes[0], - hsyncend_bytes[1], - htotal_bytes[0], - htotal_bytes[1], - hskew_bytes[0], - hskew_bytes[1], - vdisplay_bytes[0], - vdisplay_bytes[1], - vsyncstart_bytes[0], - vsyncstart_bytes[1], - vsyncend_bytes[0], - vsyncend_bytes[1], - vtotal_bytes[0], - vtotal_bytes[1], - 0, - 0, - flags_bytes[0], - flags_bytes[1], - flags_bytes[2], - flags_bytes[3], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - privsize_bytes[0], - privsize_bytes[1], - privsize_bytes[2], - privsize_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + private.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(private), IoSlice::new(&padding0)], vec![])?) + let request0 = ModModeLineRequest { + screen, + hdisplay, + hsyncstart, + hsyncend, + htotal, + hskew, + vdisplay, + vsyncstart, + vsyncend, + vtotal, + flags, + private, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SwitchMode request pub const SWITCH_MODE_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SwitchModeRequest { + pub screen: u16, + pub zoom: u16, +} +impl SwitchModeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let zoom_bytes = self.zoom.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SWITCH_MODE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + zoom_bytes[0], + zoom_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn switch_mode(conn: &Conn, screen: u16, zoom: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let zoom_bytes = zoom.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SWITCH_MODE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - zoom_bytes[0], - zoom_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SwitchModeRequest { + screen, + zoom, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetMonitor request pub const GET_MONITOR_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMonitorRequest { + pub screen: u16, +} +impl GetMonitorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MONITOR_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_monitor(conn: &Conn, screen: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MONITOR_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMonitorRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -743,57 +853,95 @@ impl GetMonitorReply { /// Opcode for the LockModeSwitch request pub const LOCK_MODE_SWITCH_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct LockModeSwitchRequest { + pub screen: u16, + pub lock: u16, +} +impl LockModeSwitchRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let lock_bytes = self.lock.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + LOCK_MODE_SWITCH_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + lock_bytes[0], + lock_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn lock_mode_switch(conn: &Conn, screen: u16, lock: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let lock_bytes = lock.serialize(); - let mut request0 = [ - extension_information.major_opcode, - LOCK_MODE_SWITCH_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - lock_bytes[0], - lock_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = LockModeSwitchRequest { + screen, + lock, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetAllModeLines request pub const GET_ALL_MODE_LINES_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetAllModeLinesRequest { + pub screen: u16, +} +impl GetAllModeLinesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_ALL_MODE_LINES_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_all_mode_lines(conn: &Conn, screen: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_ALL_MODE_LINES_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetAllModeLinesRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -840,464 +988,672 @@ impl GetAllModeLinesReply { /// Opcode for the AddModeLine request pub const ADD_MODE_LINE_REQUEST: u8 = 7; -pub fn add_mode_line<'c, Conn, A, B>(conn: &'c Conn, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, after_dotclock: Dotclock, after_hdisplay: u16, after_hsyncstart: u16, after_hsyncend: u16, after_htotal: u16, after_hskew: u16, after_vdisplay: u16, after_vsyncstart: u16, after_vsyncend: u16, after_vtotal: u16, after_flags: B, private: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AddModeLineRequest<'input> { + pub screen: u32, + pub dotclock: Dotclock, + pub hdisplay: u16, + pub hsyncstart: u16, + pub hsyncend: u16, + pub htotal: u16, + pub hskew: u16, + pub vdisplay: u16, + pub vsyncstart: u16, + pub vsyncend: u16, + pub vtotal: u16, + pub flags: u32, + pub after_dotclock: Dotclock, + pub after_hdisplay: u16, + pub after_hsyncstart: u16, + pub after_hsyncend: u16, + pub after_htotal: u16, + pub after_hskew: u16, + pub after_vdisplay: u16, + pub after_vsyncstart: u16, + pub after_vsyncend: u16, + pub after_vtotal: u16, + pub after_flags: u32, + pub private: &'input [u8], +} +impl<'input> AddModeLineRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let dotclock_bytes = self.dotclock.serialize(); + let hdisplay_bytes = self.hdisplay.serialize(); + let hsyncstart_bytes = self.hsyncstart.serialize(); + let hsyncend_bytes = self.hsyncend.serialize(); + let htotal_bytes = self.htotal.serialize(); + let hskew_bytes = self.hskew.serialize(); + let vdisplay_bytes = self.vdisplay.serialize(); + let vsyncstart_bytes = self.vsyncstart.serialize(); + let vsyncend_bytes = self.vsyncend.serialize(); + let vtotal_bytes = self.vtotal.serialize(); + let flags_bytes = self.flags.serialize(); + let privsize = u32::try_from(self.private.len()).expect("`private` has too many elements"); + let privsize_bytes = privsize.serialize(); + let after_dotclock_bytes = self.after_dotclock.serialize(); + let after_hdisplay_bytes = self.after_hdisplay.serialize(); + let after_hsyncstart_bytes = self.after_hsyncstart.serialize(); + let after_hsyncend_bytes = self.after_hsyncend.serialize(); + let after_htotal_bytes = self.after_htotal.serialize(); + let after_hskew_bytes = self.after_hskew.serialize(); + let after_vdisplay_bytes = self.after_vdisplay.serialize(); + let after_vsyncstart_bytes = self.after_vsyncstart.serialize(); + let after_vsyncend_bytes = self.after_vsyncend.serialize(); + let after_vtotal_bytes = self.after_vtotal.serialize(); + let after_flags_bytes = self.after_flags.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + ADD_MODE_LINE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + dotclock_bytes[0], + dotclock_bytes[1], + dotclock_bytes[2], + dotclock_bytes[3], + hdisplay_bytes[0], + hdisplay_bytes[1], + hsyncstart_bytes[0], + hsyncstart_bytes[1], + hsyncend_bytes[0], + hsyncend_bytes[1], + htotal_bytes[0], + htotal_bytes[1], + hskew_bytes[0], + hskew_bytes[1], + vdisplay_bytes[0], + vdisplay_bytes[1], + vsyncstart_bytes[0], + vsyncstart_bytes[1], + vsyncend_bytes[0], + vsyncend_bytes[1], + vtotal_bytes[0], + vtotal_bytes[1], + 0, + 0, + flags_bytes[0], + flags_bytes[1], + flags_bytes[2], + flags_bytes[3], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + privsize_bytes[0], + privsize_bytes[1], + privsize_bytes[2], + privsize_bytes[3], + after_dotclock_bytes[0], + after_dotclock_bytes[1], + after_dotclock_bytes[2], + after_dotclock_bytes[3], + after_hdisplay_bytes[0], + after_hdisplay_bytes[1], + after_hsyncstart_bytes[0], + after_hsyncstart_bytes[1], + after_hsyncend_bytes[0], + after_hsyncend_bytes[1], + after_htotal_bytes[0], + after_htotal_bytes[1], + after_hskew_bytes[0], + after_hskew_bytes[1], + after_vdisplay_bytes[0], + after_vdisplay_bytes[1], + after_vsyncstart_bytes[0], + after_vsyncstart_bytes[1], + after_vsyncend_bytes[0], + after_vsyncend_bytes[1], + after_vtotal_bytes[0], + after_vtotal_bytes[1], + 0, + 0, + after_flags_bytes[0], + after_flags_bytes[1], + after_flags_bytes[2], + after_flags_bytes[3], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.private[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.private[..]).into(), padding0.into()], vec![])) + } +} +pub fn add_mode_line<'c, 'input, Conn, A, B>(conn: &'c Conn, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, after_dotclock: Dotclock, after_hdisplay: u16, after_hsyncstart: u16, after_hsyncend: u16, after_htotal: u16, after_hskew: u16, after_vdisplay: u16, after_vsyncstart: u16, after_vsyncend: u16, after_vtotal: u16, after_flags: B, private: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let flags: u32 = flags.into(); let after_flags: u32 = after_flags.into(); - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let dotclock_bytes = dotclock.serialize(); - let hdisplay_bytes = hdisplay.serialize(); - let hsyncstart_bytes = hsyncstart.serialize(); - let hsyncend_bytes = hsyncend.serialize(); - let htotal_bytes = htotal.serialize(); - let hskew_bytes = hskew.serialize(); - let vdisplay_bytes = vdisplay.serialize(); - let vsyncstart_bytes = vsyncstart.serialize(); - let vsyncend_bytes = vsyncend.serialize(); - let vtotal_bytes = vtotal.serialize(); - let flags_bytes = flags.serialize(); - let privsize = u32::try_from(private.len()).expect("`private` has too many elements"); - let privsize_bytes = privsize.serialize(); - let after_dotclock_bytes = after_dotclock.serialize(); - let after_hdisplay_bytes = after_hdisplay.serialize(); - let after_hsyncstart_bytes = after_hsyncstart.serialize(); - let after_hsyncend_bytes = after_hsyncend.serialize(); - let after_htotal_bytes = after_htotal.serialize(); - let after_hskew_bytes = after_hskew.serialize(); - let after_vdisplay_bytes = after_vdisplay.serialize(); - let after_vsyncstart_bytes = after_vsyncstart.serialize(); - let after_vsyncend_bytes = after_vsyncend.serialize(); - let after_vtotal_bytes = after_vtotal.serialize(); - let after_flags_bytes = after_flags.serialize(); - let mut request0 = [ - extension_information.major_opcode, - ADD_MODE_LINE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - dotclock_bytes[0], - dotclock_bytes[1], - dotclock_bytes[2], - dotclock_bytes[3], - hdisplay_bytes[0], - hdisplay_bytes[1], - hsyncstart_bytes[0], - hsyncstart_bytes[1], - hsyncend_bytes[0], - hsyncend_bytes[1], - htotal_bytes[0], - htotal_bytes[1], - hskew_bytes[0], - hskew_bytes[1], - vdisplay_bytes[0], - vdisplay_bytes[1], - vsyncstart_bytes[0], - vsyncstart_bytes[1], - vsyncend_bytes[0], - vsyncend_bytes[1], - vtotal_bytes[0], - vtotal_bytes[1], - 0, - 0, - flags_bytes[0], - flags_bytes[1], - flags_bytes[2], - flags_bytes[3], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - privsize_bytes[0], - privsize_bytes[1], - privsize_bytes[2], - privsize_bytes[3], - after_dotclock_bytes[0], - after_dotclock_bytes[1], - after_dotclock_bytes[2], - after_dotclock_bytes[3], - after_hdisplay_bytes[0], - after_hdisplay_bytes[1], - after_hsyncstart_bytes[0], - after_hsyncstart_bytes[1], - after_hsyncend_bytes[0], - after_hsyncend_bytes[1], - after_htotal_bytes[0], - after_htotal_bytes[1], - after_hskew_bytes[0], - after_hskew_bytes[1], - after_vdisplay_bytes[0], - after_vdisplay_bytes[1], - after_vsyncstart_bytes[0], - after_vsyncstart_bytes[1], - after_vsyncend_bytes[0], - after_vsyncend_bytes[1], - after_vtotal_bytes[0], - after_vtotal_bytes[1], - 0, - 0, - after_flags_bytes[0], - after_flags_bytes[1], - after_flags_bytes[2], - after_flags_bytes[3], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + private.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(private), IoSlice::new(&padding0)], vec![])?) + let request0 = AddModeLineRequest { + screen, + dotclock, + hdisplay, + hsyncstart, + hsyncend, + htotal, + hskew, + vdisplay, + vsyncstart, + vsyncend, + vtotal, + flags, + after_dotclock, + after_hdisplay, + after_hsyncstart, + after_hsyncend, + after_htotal, + after_hskew, + after_vdisplay, + after_vsyncstart, + after_vsyncend, + after_vtotal, + after_flags, + private, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeleteModeLine request pub const DELETE_MODE_LINE_REQUEST: u8 = 8; -pub fn delete_mode_line<'c, Conn, A>(conn: &'c Conn, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &[u8]) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, - A: Into, -{ - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let flags: u32 = flags.into(); - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let dotclock_bytes = dotclock.serialize(); - let hdisplay_bytes = hdisplay.serialize(); - let hsyncstart_bytes = hsyncstart.serialize(); - let hsyncend_bytes = hsyncend.serialize(); - let htotal_bytes = htotal.serialize(); - let hskew_bytes = hskew.serialize(); - let vdisplay_bytes = vdisplay.serialize(); - let vsyncstart_bytes = vsyncstart.serialize(); - let vsyncend_bytes = vsyncend.serialize(); - let vtotal_bytes = vtotal.serialize(); - let flags_bytes = flags.serialize(); - let privsize = u32::try_from(private.len()).expect("`private` has too many elements"); - let privsize_bytes = privsize.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_MODE_LINE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - dotclock_bytes[0], - dotclock_bytes[1], - dotclock_bytes[2], - dotclock_bytes[3], - hdisplay_bytes[0], - hdisplay_bytes[1], - hsyncstart_bytes[0], - hsyncstart_bytes[1], - hsyncend_bytes[0], - hsyncend_bytes[1], - htotal_bytes[0], - htotal_bytes[1], - hskew_bytes[0], - hskew_bytes[1], - vdisplay_bytes[0], - vdisplay_bytes[1], - vsyncstart_bytes[0], - vsyncstart_bytes[1], - vsyncend_bytes[0], - vsyncend_bytes[1], - vtotal_bytes[0], - vtotal_bytes[1], - 0, - 0, - flags_bytes[0], - flags_bytes[1], - flags_bytes[2], - flags_bytes[3], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - privsize_bytes[0], - privsize_bytes[1], - privsize_bytes[2], - privsize_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + private.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(private), IoSlice::new(&padding0)], vec![])?) -} - -/// Opcode for the ValidateModeLine request -pub const VALIDATE_MODE_LINE_REQUEST: u8 = 9; -pub fn validate_mode_line<'c, Conn, A>(conn: &'c Conn, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &[u8]) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, - A: Into, -{ - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let flags: u32 = flags.into(); - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let dotclock_bytes = dotclock.serialize(); - let hdisplay_bytes = hdisplay.serialize(); - let hsyncstart_bytes = hsyncstart.serialize(); - let hsyncend_bytes = hsyncend.serialize(); - let htotal_bytes = htotal.serialize(); - let hskew_bytes = hskew.serialize(); - let vdisplay_bytes = vdisplay.serialize(); - let vsyncstart_bytes = vsyncstart.serialize(); - let vsyncend_bytes = vsyncend.serialize(); - let vtotal_bytes = vtotal.serialize(); - let flags_bytes = flags.serialize(); - let privsize = u32::try_from(private.len()).expect("`private` has too many elements"); - let privsize_bytes = privsize.serialize(); - let mut request0 = [ - extension_information.major_opcode, - VALIDATE_MODE_LINE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - dotclock_bytes[0], - dotclock_bytes[1], - dotclock_bytes[2], - dotclock_bytes[3], - hdisplay_bytes[0], - hdisplay_bytes[1], - hsyncstart_bytes[0], - hsyncstart_bytes[1], - hsyncend_bytes[0], - hsyncend_bytes[1], - htotal_bytes[0], - htotal_bytes[1], - hskew_bytes[0], - hskew_bytes[1], - vdisplay_bytes[0], - vdisplay_bytes[1], - vsyncstart_bytes[0], - vsyncstart_bytes[1], - vsyncend_bytes[0], - vsyncend_bytes[1], - vtotal_bytes[0], - vtotal_bytes[1], - 0, - 0, - flags_bytes[0], - flags_bytes[1], - flags_bytes[2], - flags_bytes[3], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - privsize_bytes[0], - privsize_bytes[1], - privsize_bytes[2], - privsize_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + private.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(private), IoSlice::new(&padding0)], vec![])?) -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct ValidateModeLineReply { - pub response_type: u8, - pub sequence: u16, - pub length: u32, - pub status: u32, -} -impl TryParse for ValidateModeLineReply { - fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> { - let (response_type, remaining) = u8::try_parse(remaining)?; - let remaining = remaining.get(1..).ok_or(ParseError::ParseError)?; - let (sequence, remaining) = u16::try_parse(remaining)?; - let (length, remaining) = u32::try_parse(remaining)?; - let (status, remaining) = u32::try_parse(remaining)?; - let remaining = remaining.get(20..).ok_or(ParseError::ParseError)?; - let result = ValidateModeLineReply { response_type, sequence, length, status }; - Ok((result, remaining)) - } -} -impl TryFrom<&[u8]> for ValidateModeLineReply { - type Error = ParseError; - fn try_from(value: &[u8]) -> Result { - Ok(Self::try_parse(value)?.0) - } +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct DeleteModeLineRequest<'input> { + pub screen: u32, + pub dotclock: Dotclock, + pub hdisplay: u16, + pub hsyncstart: u16, + pub hsyncend: u16, + pub htotal: u16, + pub hskew: u16, + pub vdisplay: u16, + pub vsyncstart: u16, + pub vsyncend: u16, + pub vtotal: u16, + pub flags: u32, + pub private: &'input [u8], } - -/// Opcode for the SwitchToMode request -pub const SWITCH_TO_MODE_REQUEST: u8 = 10; -pub fn switch_to_mode<'c, Conn, A>(conn: &'c Conn, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &[u8]) -> Result, ConnectionError> -where +impl<'input> DeleteModeLineRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let dotclock_bytes = self.dotclock.serialize(); + let hdisplay_bytes = self.hdisplay.serialize(); + let hsyncstart_bytes = self.hsyncstart.serialize(); + let hsyncend_bytes = self.hsyncend.serialize(); + let htotal_bytes = self.htotal.serialize(); + let hskew_bytes = self.hskew.serialize(); + let vdisplay_bytes = self.vdisplay.serialize(); + let vsyncstart_bytes = self.vsyncstart.serialize(); + let vsyncend_bytes = self.vsyncend.serialize(); + let vtotal_bytes = self.vtotal.serialize(); + let flags_bytes = self.flags.serialize(); + let privsize = u32::try_from(self.private.len()).expect("`private` has too many elements"); + let privsize_bytes = privsize.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_MODE_LINE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + dotclock_bytes[0], + dotclock_bytes[1], + dotclock_bytes[2], + dotclock_bytes[3], + hdisplay_bytes[0], + hdisplay_bytes[1], + hsyncstart_bytes[0], + hsyncstart_bytes[1], + hsyncend_bytes[0], + hsyncend_bytes[1], + htotal_bytes[0], + htotal_bytes[1], + hskew_bytes[0], + hskew_bytes[1], + vdisplay_bytes[0], + vdisplay_bytes[1], + vsyncstart_bytes[0], + vsyncstart_bytes[1], + vsyncend_bytes[0], + vsyncend_bytes[1], + vtotal_bytes[0], + vtotal_bytes[1], + 0, + 0, + flags_bytes[0], + flags_bytes[1], + flags_bytes[2], + flags_bytes[3], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + privsize_bytes[0], + privsize_bytes[1], + privsize_bytes[2], + privsize_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.private[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.private[..]).into(), padding0.into()], vec![])) + } +} +pub fn delete_mode_line<'c, 'input, Conn, A>(conn: &'c Conn, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &'input [u8]) -> Result, ConnectionError> +where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let flags: u32 = flags.into(); - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let dotclock_bytes = dotclock.serialize(); - let hdisplay_bytes = hdisplay.serialize(); - let hsyncstart_bytes = hsyncstart.serialize(); - let hsyncend_bytes = hsyncend.serialize(); - let htotal_bytes = htotal.serialize(); - let hskew_bytes = hskew.serialize(); - let vdisplay_bytes = vdisplay.serialize(); - let vsyncstart_bytes = vsyncstart.serialize(); - let vsyncend_bytes = vsyncend.serialize(); - let vtotal_bytes = vtotal.serialize(); - let flags_bytes = flags.serialize(); - let privsize = u32::try_from(private.len()).expect("`private` has too many elements"); - let privsize_bytes = privsize.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SWITCH_TO_MODE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - dotclock_bytes[0], - dotclock_bytes[1], - dotclock_bytes[2], - dotclock_bytes[3], - hdisplay_bytes[0], - hdisplay_bytes[1], - hsyncstart_bytes[0], - hsyncstart_bytes[1], - hsyncend_bytes[0], - hsyncend_bytes[1], - htotal_bytes[0], - htotal_bytes[1], - hskew_bytes[0], - hskew_bytes[1], - vdisplay_bytes[0], - vdisplay_bytes[1], - vsyncstart_bytes[0], - vsyncstart_bytes[1], - vsyncend_bytes[0], - vsyncend_bytes[1], - vtotal_bytes[0], - vtotal_bytes[1], - 0, - 0, - flags_bytes[0], - flags_bytes[1], - flags_bytes[2], - flags_bytes[3], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - privsize_bytes[0], - privsize_bytes[1], - privsize_bytes[2], - privsize_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + private.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(private), IoSlice::new(&padding0)], vec![])?) + let request0 = DeleteModeLineRequest { + screen, + dotclock, + hdisplay, + hsyncstart, + hsyncend, + htotal, + hskew, + vdisplay, + vsyncstart, + vsyncend, + vtotal, + flags, + private, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) +} + +/// Opcode for the ValidateModeLine request +pub const VALIDATE_MODE_LINE_REQUEST: u8 = 9; +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ValidateModeLineRequest<'input> { + pub screen: u32, + pub dotclock: Dotclock, + pub hdisplay: u16, + pub hsyncstart: u16, + pub hsyncend: u16, + pub htotal: u16, + pub hskew: u16, + pub vdisplay: u16, + pub vsyncstart: u16, + pub vsyncend: u16, + pub vtotal: u16, + pub flags: u32, + pub private: &'input [u8], +} +impl<'input> ValidateModeLineRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let dotclock_bytes = self.dotclock.serialize(); + let hdisplay_bytes = self.hdisplay.serialize(); + let hsyncstart_bytes = self.hsyncstart.serialize(); + let hsyncend_bytes = self.hsyncend.serialize(); + let htotal_bytes = self.htotal.serialize(); + let hskew_bytes = self.hskew.serialize(); + let vdisplay_bytes = self.vdisplay.serialize(); + let vsyncstart_bytes = self.vsyncstart.serialize(); + let vsyncend_bytes = self.vsyncend.serialize(); + let vtotal_bytes = self.vtotal.serialize(); + let flags_bytes = self.flags.serialize(); + let privsize = u32::try_from(self.private.len()).expect("`private` has too many elements"); + let privsize_bytes = privsize.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + VALIDATE_MODE_LINE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + dotclock_bytes[0], + dotclock_bytes[1], + dotclock_bytes[2], + dotclock_bytes[3], + hdisplay_bytes[0], + hdisplay_bytes[1], + hsyncstart_bytes[0], + hsyncstart_bytes[1], + hsyncend_bytes[0], + hsyncend_bytes[1], + htotal_bytes[0], + htotal_bytes[1], + hskew_bytes[0], + hskew_bytes[1], + vdisplay_bytes[0], + vdisplay_bytes[1], + vsyncstart_bytes[0], + vsyncstart_bytes[1], + vsyncend_bytes[0], + vsyncend_bytes[1], + vtotal_bytes[0], + vtotal_bytes[1], + 0, + 0, + flags_bytes[0], + flags_bytes[1], + flags_bytes[2], + flags_bytes[3], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + privsize_bytes[0], + privsize_bytes[1], + privsize_bytes[2], + privsize_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.private[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.private[..]).into(), padding0.into()], vec![])) + } +} +pub fn validate_mode_line<'c, 'input, Conn, A>(conn: &'c Conn, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &'input [u8]) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, + A: Into, +{ + let flags: u32 = flags.into(); + let request0 = ValidateModeLineRequest { + screen, + dotclock, + hdisplay, + hsyncstart, + hsyncend, + htotal, + hskew, + vdisplay, + vsyncstart, + vsyncend, + vtotal, + flags, + private, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ValidateModeLineReply { + pub response_type: u8, + pub sequence: u16, + pub length: u32, + pub status: u32, +} +impl TryParse for ValidateModeLineReply { + fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> { + let (response_type, remaining) = u8::try_parse(remaining)?; + let remaining = remaining.get(1..).ok_or(ParseError::ParseError)?; + let (sequence, remaining) = u16::try_parse(remaining)?; + let (length, remaining) = u32::try_parse(remaining)?; + let (status, remaining) = u32::try_parse(remaining)?; + let remaining = remaining.get(20..).ok_or(ParseError::ParseError)?; + let result = ValidateModeLineReply { response_type, sequence, length, status }; + Ok((result, remaining)) + } +} +impl TryFrom<&[u8]> for ValidateModeLineReply { + type Error = ParseError; + fn try_from(value: &[u8]) -> Result { + Ok(Self::try_parse(value)?.0) + } +} + +/// Opcode for the SwitchToMode request +pub const SWITCH_TO_MODE_REQUEST: u8 = 10; +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SwitchToModeRequest<'input> { + pub screen: u32, + pub dotclock: Dotclock, + pub hdisplay: u16, + pub hsyncstart: u16, + pub hsyncend: u16, + pub htotal: u16, + pub hskew: u16, + pub vdisplay: u16, + pub vsyncstart: u16, + pub vsyncend: u16, + pub vtotal: u16, + pub flags: u32, + pub private: &'input [u8], +} +impl<'input> SwitchToModeRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let dotclock_bytes = self.dotclock.serialize(); + let hdisplay_bytes = self.hdisplay.serialize(); + let hsyncstart_bytes = self.hsyncstart.serialize(); + let hsyncend_bytes = self.hsyncend.serialize(); + let htotal_bytes = self.htotal.serialize(); + let hskew_bytes = self.hskew.serialize(); + let vdisplay_bytes = self.vdisplay.serialize(); + let vsyncstart_bytes = self.vsyncstart.serialize(); + let vsyncend_bytes = self.vsyncend.serialize(); + let vtotal_bytes = self.vtotal.serialize(); + let flags_bytes = self.flags.serialize(); + let privsize = u32::try_from(self.private.len()).expect("`private` has too many elements"); + let privsize_bytes = privsize.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SWITCH_TO_MODE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + dotclock_bytes[0], + dotclock_bytes[1], + dotclock_bytes[2], + dotclock_bytes[3], + hdisplay_bytes[0], + hdisplay_bytes[1], + hsyncstart_bytes[0], + hsyncstart_bytes[1], + hsyncend_bytes[0], + hsyncend_bytes[1], + htotal_bytes[0], + htotal_bytes[1], + hskew_bytes[0], + hskew_bytes[1], + vdisplay_bytes[0], + vdisplay_bytes[1], + vsyncstart_bytes[0], + vsyncstart_bytes[1], + vsyncend_bytes[0], + vsyncend_bytes[1], + vtotal_bytes[0], + vtotal_bytes[1], + 0, + 0, + flags_bytes[0], + flags_bytes[1], + flags_bytes[2], + flags_bytes[3], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + privsize_bytes[0], + privsize_bytes[1], + privsize_bytes[2], + privsize_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.private[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.private[..]).into(), padding0.into()], vec![])) + } +} +pub fn switch_to_mode<'c, 'input, Conn, A>(conn: &'c Conn, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &'input [u8]) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, + A: Into, +{ + let flags: u32 = flags.into(); + let request0 = SwitchToModeRequest { + screen, + dotclock, + hdisplay, + hsyncstart, + hsyncend, + htotal, + hskew, + vdisplay, + vsyncstart, + vsyncend, + vtotal, + flags, + private, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetViewPort request pub const GET_VIEW_PORT_REQUEST: u8 = 11; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetViewPortRequest { + pub screen: u16, +} +impl GetViewPortRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_VIEW_PORT_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_view_port(conn: &Conn, screen: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_VIEW_PORT_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetViewPortRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1330,66 +1686,106 @@ impl TryFrom<&[u8]> for GetViewPortReply { /// Opcode for the SetViewPort request pub const SET_VIEW_PORT_REQUEST: u8 = 12; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetViewPortRequest { + pub screen: u16, + pub x: u32, + pub y: u32, +} +impl SetViewPortRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_VIEW_PORT_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + 0, + 0, + x_bytes[0], + x_bytes[1], + x_bytes[2], + x_bytes[3], + y_bytes[0], + y_bytes[1], + y_bytes[2], + y_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_view_port(conn: &Conn, screen: u16, x: u32, y: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_VIEW_PORT_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - 0, - 0, - x_bytes[0], - x_bytes[1], - x_bytes[2], - x_bytes[3], - y_bytes[0], - y_bytes[1], - y_bytes[2], - y_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetViewPortRequest { + screen, + x, + y, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetDotClocks request pub const GET_DOT_CLOCKS_REQUEST: u8 = 13; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDotClocksRequest { + pub screen: u16, +} +impl GetDotClocksRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DOT_CLOCKS_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_dot_clocks(conn: &Conn, screen: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DOT_CLOCKS_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDotClocksRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1426,135 +1822,197 @@ impl TryFrom<&[u8]> for GetDotClocksReply { /// Opcode for the SetClientVersion request pub const SET_CLIENT_VERSION_REQUEST: u8 = 14; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetClientVersionRequest { + pub major: u16, + pub minor: u16, +} +impl SetClientVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_bytes = self.major.serialize(); + let minor_bytes = self.minor.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_CLIENT_VERSION_REQUEST, + 0, + 0, + major_bytes[0], + major_bytes[1], + minor_bytes[0], + minor_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_client_version(conn: &Conn, major: u16, minor: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_bytes = major.serialize(); - let minor_bytes = minor.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_CLIENT_VERSION_REQUEST, - 0, - 0, - major_bytes[0], - major_bytes[1], - minor_bytes[0], - minor_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetClientVersionRequest { + major, + minor, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetGamma request pub const SET_GAMMA_REQUEST: u8 = 15; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetGammaRequest { + pub screen: u16, + pub red: u32, + pub green: u32, + pub blue: u32, +} +impl SetGammaRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let red_bytes = self.red.serialize(); + let green_bytes = self.green.serialize(); + let blue_bytes = self.blue.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_GAMMA_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + 0, + 0, + red_bytes[0], + red_bytes[1], + red_bytes[2], + red_bytes[3], + green_bytes[0], + green_bytes[1], + green_bytes[2], + green_bytes[3], + blue_bytes[0], + blue_bytes[1], + blue_bytes[2], + blue_bytes[3], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_gamma(conn: &Conn, screen: u16, red: u32, green: u32, blue: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let red_bytes = red.serialize(); - let green_bytes = green.serialize(); - let blue_bytes = blue.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_GAMMA_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - 0, - 0, - red_bytes[0], - red_bytes[1], - red_bytes[2], - red_bytes[3], - green_bytes[0], - green_bytes[1], - green_bytes[2], - green_bytes[3], - blue_bytes[0], - blue_bytes[1], - blue_bytes[2], - blue_bytes[3], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetGammaRequest { + screen, + red, + green, + blue, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetGamma request pub const GET_GAMMA_REQUEST: u8 = 16; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetGammaRequest { + pub screen: u16, +} +impl GetGammaRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_GAMMA_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_gamma(conn: &Conn, screen: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_GAMMA_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetGammaRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1589,30 +2047,50 @@ impl TryFrom<&[u8]> for GetGammaReply { /// Opcode for the GetGammaRamp request pub const GET_GAMMA_RAMP_REQUEST: u8 = 17; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetGammaRampRequest { + pub screen: u16, + pub size: u16, +} +impl GetGammaRampRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let size_bytes = self.size.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_GAMMA_RAMP_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + size_bytes[0], + size_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_gamma_ramp(conn: &Conn, screen: u16, size: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let size_bytes = size.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_GAMMA_RAMP_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - size_bytes[0], - size_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetGammaRampRequest { + screen, + size, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1649,68 +2127,112 @@ impl TryFrom<&[u8]> for GetGammaRampReply { /// Opcode for the SetGammaRamp request pub const SET_GAMMA_RAMP_REQUEST: u8 = 18; -pub fn set_gamma_ramp<'c, Conn>(conn: &'c Conn, screen: u16, size: u16, red: &[u16], green: &[u16], blue: &[u16]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetGammaRampRequest<'input> { + pub screen: u16, + pub size: u16, + pub red: &'input [u16], + pub green: &'input [u16], + pub blue: &'input [u16], +} +impl<'input> SetGammaRampRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let size_bytes = self.size.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_GAMMA_RAMP_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + size_bytes[0], + size_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(self.red.len(), usize::try_from(u32::from(self.size).checked_add(1u32).unwrap() & (!1u32)).unwrap(), "`red` has an incorrect length"); + let red_bytes = self.red.serialize(); + let length_so_far = length_so_far + red_bytes.len(); + assert_eq!(self.green.len(), usize::try_from(u32::from(self.size).checked_add(1u32).unwrap() & (!1u32)).unwrap(), "`green` has an incorrect length"); + let green_bytes = self.green.serialize(); + let length_so_far = length_so_far + green_bytes.len(); + assert_eq!(self.blue.len(), usize::try_from(u32::from(self.size).checked_add(1u32).unwrap() & (!1u32)).unwrap(), "`blue` has an incorrect length"); + let blue_bytes = self.blue.serialize(); + let length_so_far = length_so_far + blue_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), red_bytes.into(), green_bytes.into(), blue_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_gamma_ramp<'c, 'input, Conn>(conn: &'c Conn, screen: u16, size: u16, red: &'input [u16], green: &'input [u16], blue: &'input [u16]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let size_bytes = size.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_GAMMA_RAMP_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - size_bytes[0], - size_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(red.len(), usize::try_from(u32::from(size).checked_add(1u32).unwrap() & (!1u32)).unwrap(), "`red` has an incorrect length"); - let red_bytes = red.serialize(); - let length_so_far = length_so_far + red_bytes.len(); - assert_eq!(green.len(), usize::try_from(u32::from(size).checked_add(1u32).unwrap() & (!1u32)).unwrap(), "`green` has an incorrect length"); - let green_bytes = green.serialize(); - let length_so_far = length_so_far + green_bytes.len(); - assert_eq!(blue.len(), usize::try_from(u32::from(size).checked_add(1u32).unwrap() & (!1u32)).unwrap(), "`blue` has an incorrect length"); - let blue_bytes = blue.serialize(); - let length_so_far = length_so_far + blue_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&red_bytes), IoSlice::new(&green_bytes), IoSlice::new(&blue_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetGammaRampRequest { + screen, + size, + red, + green, + blue, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetGammaRampSize request pub const GET_GAMMA_RAMP_SIZE_REQUEST: u8 = 19; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetGammaRampSizeRequest { + pub screen: u16, +} +impl GetGammaRampSizeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_GAMMA_RAMP_SIZE_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_gamma_ramp_size(conn: &Conn, screen: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_GAMMA_RAMP_SIZE_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetGammaRampSizeRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1741,29 +2263,47 @@ impl TryFrom<&[u8]> for GetGammaRampSizeReply { /// Opcode for the GetPermissions request pub const GET_PERMISSIONS_REQUEST: u8 = 20; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPermissionsRequest { + pub screen: u16, +} +impl GetPermissionsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PERMISSIONS_REQUEST, + 0, + 0, + screen_bytes[0], + screen_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_permissions(conn: &Conn, screen: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PERMISSIONS_REQUEST, - 0, - 0, - screen_bytes[0], - screen_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPermissionsRequest { + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -2299,7 +2839,7 @@ pub trait ConnectionExt: RequestConnection { { get_mode_line(self, screen) } - fn xf86vidmode_mod_mode_line<'c, A>(&'c self, screen: u32, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &[u8]) -> Result, ConnectionError> + fn xf86vidmode_mod_mode_line<'c, 'input, A>(&'c self, screen: u32, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &'input [u8]) -> Result, ConnectionError> where A: Into, { @@ -2321,26 +2861,26 @@ pub trait ConnectionExt: RequestConnection { { get_all_mode_lines(self, screen) } - fn xf86vidmode_add_mode_line<'c, A, B>(&'c self, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, after_dotclock: Dotclock, after_hdisplay: u16, after_hsyncstart: u16, after_hsyncend: u16, after_htotal: u16, after_hskew: u16, after_vdisplay: u16, after_vsyncstart: u16, after_vsyncend: u16, after_vtotal: u16, after_flags: B, private: &[u8]) -> Result, ConnectionError> + fn xf86vidmode_add_mode_line<'c, 'input, A, B>(&'c self, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, after_dotclock: Dotclock, after_hdisplay: u16, after_hsyncstart: u16, after_hsyncend: u16, after_htotal: u16, after_hskew: u16, after_vdisplay: u16, after_vsyncstart: u16, after_vsyncend: u16, after_vtotal: u16, after_flags: B, private: &'input [u8]) -> Result, ConnectionError> where A: Into, B: Into, { add_mode_line(self, screen, dotclock, hdisplay, hsyncstart, hsyncend, htotal, hskew, vdisplay, vsyncstart, vsyncend, vtotal, flags, after_dotclock, after_hdisplay, after_hsyncstart, after_hsyncend, after_htotal, after_hskew, after_vdisplay, after_vsyncstart, after_vsyncend, after_vtotal, after_flags, private) } - fn xf86vidmode_delete_mode_line<'c, A>(&'c self, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &[u8]) -> Result, ConnectionError> + fn xf86vidmode_delete_mode_line<'c, 'input, A>(&'c self, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &'input [u8]) -> Result, ConnectionError> where A: Into, { delete_mode_line(self, screen, dotclock, hdisplay, hsyncstart, hsyncend, htotal, hskew, vdisplay, vsyncstart, vsyncend, vtotal, flags, private) } - fn xf86vidmode_validate_mode_line<'c, A>(&'c self, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &[u8]) -> Result, ConnectionError> + fn xf86vidmode_validate_mode_line<'c, 'input, A>(&'c self, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &'input [u8]) -> Result, ConnectionError> where A: Into, { validate_mode_line(self, screen, dotclock, hdisplay, hsyncstart, hsyncend, htotal, hskew, vdisplay, vsyncstart, vsyncend, vtotal, flags, private) } - fn xf86vidmode_switch_to_mode<'c, A>(&'c self, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &[u8]) -> Result, ConnectionError> + fn xf86vidmode_switch_to_mode<'c, 'input, A>(&'c self, screen: u32, dotclock: Dotclock, hdisplay: u16, hsyncstart: u16, hsyncend: u16, htotal: u16, hskew: u16, vdisplay: u16, vsyncstart: u16, vsyncend: u16, vtotal: u16, flags: A, private: &'input [u8]) -> Result, ConnectionError> where A: Into, { @@ -2374,7 +2914,7 @@ pub trait ConnectionExt: RequestConnection { { get_gamma_ramp(self, screen, size) } - fn xf86vidmode_set_gamma_ramp<'c>(&'c self, screen: u16, size: u16, red: &[u16], green: &[u16], blue: &[u16]) -> Result, ConnectionError> + fn xf86vidmode_set_gamma_ramp<'c, 'input>(&'c self, screen: u16, size: u16, red: &'input [u16], green: &'input [u16], blue: &'input [u16]) -> Result, ConnectionError> { set_gamma_ramp(self, screen, size, red, green, blue) } diff --git a/src/protocol/xfixes.rs b/src/protocol/xfixes.rs index cca898f7..cf0f5063 100644 --- a/src/protocol/xfixes.rs +++ b/src/protocol/xfixes.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -37,34 +37,54 @@ pub const X11_XML_VERSION: (u32, u32) = (5, 0); /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub client_major_version: u32, + pub client_minor_version: u32, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_version_bytes = self.client_major_version.serialize(); + let client_minor_version_bytes = self.client_minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + client_major_version_bytes[0], + client_major_version_bytes[1], + client_major_version_bytes[2], + client_major_version_bytes[3], + client_minor_version_bytes[0], + client_minor_version_bytes[1], + client_minor_version_bytes[2], + client_minor_version_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, client_major_version: u32, client_minor_version: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_version_bytes = client_major_version.serialize(); - let client_minor_version_bytes = client_minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - client_major_version_bytes[0], - client_major_version_bytes[1], - client_major_version_bytes[2], - client_major_version_bytes[3], - client_minor_version_bytes[0], - client_minor_version_bytes[1], - client_minor_version_bytes[2], - client_minor_version_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + client_major_version, + client_minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -307,36 +327,60 @@ impl TryFrom for SaveSetMapping { /// Opcode for the ChangeSaveSet request pub const CHANGE_SAVE_SET_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangeSaveSetRequest { + pub mode: SaveSetMode, + pub target: SaveSetTarget, + pub map: SaveSetMapping, + pub window: xproto::Window, +} +impl ChangeSaveSetRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mode_bytes = u8::from(self.mode).serialize(); + let target_bytes = u8::from(self.target).serialize(); + let map_bytes = u8::from(self.map).serialize(); + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_SAVE_SET_REQUEST, + 0, + 0, + mode_bytes[0], + target_bytes[0], + map_bytes[0], + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn change_save_set(conn: &Conn, mode: SaveSetMode, target: SaveSetTarget, map: SaveSetMapping, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mode_bytes = u8::from(mode).serialize(); - let target_bytes = u8::from(target).serialize(); - let map_bytes = u8::from(map).serialize(); - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_SAVE_SET_REQUEST, - 0, - 0, - mode_bytes[0], - target_bytes[0], - map_bytes[0], - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ChangeSaveSetRequest { + mode, + target, + map, + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -559,41 +603,63 @@ impl From for [u8; 32] { /// Opcode for the SelectSelectionInput request pub const SELECT_SELECTION_INPUT_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectSelectionInputRequest { + pub window: xproto::Window, + pub selection: xproto::Atom, + pub event_mask: u32, +} +impl SelectSelectionInputRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let selection_bytes = self.selection.serialize(); + let event_mask_bytes = self.event_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_SELECTION_INPUT_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + selection_bytes[0], + selection_bytes[1], + selection_bytes[2], + selection_bytes[3], + event_mask_bytes[0], + event_mask_bytes[1], + event_mask_bytes[2], + event_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn select_selection_input(conn: &Conn, window: xproto::Window, selection: xproto::Atom, event_mask: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let event_mask: u32 = event_mask.into(); - let length_so_far = 0; - let window_bytes = window.serialize(); - let selection_bytes = selection.serialize(); - let event_mask_bytes = event_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_SELECTION_INPUT_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - selection_bytes[0], - selection_bytes[1], - selection_bytes[2], - selection_bytes[3], - event_mask_bytes[0], - event_mask_bytes[1], - event_mask_bytes[2], - event_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SelectSelectionInputRequest { + window, + selection, + event_mask, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -801,58 +867,92 @@ impl From for [u8; 32] { /// Opcode for the SelectCursorInput request pub const SELECT_CURSOR_INPUT_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectCursorInputRequest { + pub window: xproto::Window, + pub event_mask: u32, +} +impl SelectCursorInputRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let event_mask_bytes = self.event_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_CURSOR_INPUT_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + event_mask_bytes[0], + event_mask_bytes[1], + event_mask_bytes[2], + event_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn select_cursor_input(conn: &Conn, window: xproto::Window, event_mask: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let event_mask: u32 = event_mask.into(); - let length_so_far = 0; - let window_bytes = window.serialize(); - let event_mask_bytes = event_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_CURSOR_INPUT_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - event_mask_bytes[0], - event_mask_bytes[1], - event_mask_bytes[2], - event_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SelectCursorInputRequest { + window, + event_mask, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetCursorImage request pub const GET_CURSOR_IMAGE_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetCursorImageRequest; +impl GetCursorImageRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + GET_CURSOR_IMAGE_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_cursor_image(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - GET_CURSOR_IMAGE_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetCursorImageRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1029,500 +1129,808 @@ impl TryFrom for RegionEnum { /// Opcode for the CreateRegion request pub const CREATE_REGION_REQUEST: u8 = 5; -pub fn create_region<'c, Conn>(conn: &'c Conn, region: Region, rectangles: &[xproto::Rectangle]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateRegionRequest<'input> { + pub region: Region, + pub rectangles: &'input [xproto::Rectangle], +} +impl<'input> CreateRegionRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let region_bytes = self.region.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_REGION_REQUEST, + 0, + 0, + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let rectangles_bytes = self.rectangles.serialize(); + let length_so_far = length_so_far + rectangles_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), rectangles_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_region<'c, 'input, Conn>(conn: &'c Conn, region: Region, rectangles: &'input [xproto::Rectangle]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let region_bytes = region.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_REGION_REQUEST, - 0, - 0, - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let rectangles_bytes = rectangles.serialize(); - let length_so_far = length_so_far + rectangles_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&rectangles_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateRegionRequest { + region, + rectangles, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateRegionFromBitmap request pub const CREATE_REGION_FROM_BITMAP_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateRegionFromBitmapRequest { + pub region: Region, + pub bitmap: xproto::Pixmap, +} +impl CreateRegionFromBitmapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let region_bytes = self.region.serialize(); + let bitmap_bytes = self.bitmap.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_REGION_FROM_BITMAP_REQUEST, + 0, + 0, + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + bitmap_bytes[0], + bitmap_bytes[1], + bitmap_bytes[2], + bitmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_region_from_bitmap(conn: &Conn, region: Region, bitmap: xproto::Pixmap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let region_bytes = region.serialize(); - let bitmap_bytes = bitmap.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_REGION_FROM_BITMAP_REQUEST, - 0, - 0, - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - bitmap_bytes[0], - bitmap_bytes[1], - bitmap_bytes[2], - bitmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateRegionFromBitmapRequest { + region, + bitmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateRegionFromWindow request pub const CREATE_REGION_FROM_WINDOW_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateRegionFromWindowRequest { + pub region: Region, + pub window: xproto::Window, + pub kind: shape::SK, +} +impl CreateRegionFromWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let region_bytes = self.region.serialize(); + let window_bytes = self.window.serialize(); + let kind_bytes = shape::Kind::from(self.kind).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_REGION_FROM_WINDOW_REQUEST, + 0, + 0, + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + kind_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_region_from_window(conn: &Conn, region: Region, window: xproto::Window, kind: shape::SK) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let region_bytes = region.serialize(); - let window_bytes = window.serialize(); - let kind_bytes = shape::Kind::from(kind).serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_REGION_FROM_WINDOW_REQUEST, - 0, - 0, - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - kind_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateRegionFromWindowRequest { + region, + window, + kind, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateRegionFromGC request pub const CREATE_REGION_FROM_GC_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateRegionFromGCRequest { + pub region: Region, + pub gc: xproto::Gcontext, +} +impl CreateRegionFromGCRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let region_bytes = self.region.serialize(); + let gc_bytes = self.gc.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_REGION_FROM_GC_REQUEST, + 0, + 0, + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_region_from_gc(conn: &Conn, region: Region, gc: xproto::Gcontext) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let region_bytes = region.serialize(); - let gc_bytes = gc.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_REGION_FROM_GC_REQUEST, - 0, - 0, - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateRegionFromGCRequest { + region, + gc, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateRegionFromPicture request pub const CREATE_REGION_FROM_PICTURE_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateRegionFromPictureRequest { + pub region: Region, + pub picture: render::Picture, +} +impl CreateRegionFromPictureRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let region_bytes = self.region.serialize(); + let picture_bytes = self.picture.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_REGION_FROM_PICTURE_REQUEST, + 0, + 0, + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_region_from_picture(conn: &Conn, region: Region, picture: render::Picture) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let region_bytes = region.serialize(); - let picture_bytes = picture.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_REGION_FROM_PICTURE_REQUEST, - 0, - 0, - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateRegionFromPictureRequest { + region, + picture, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DestroyRegion request pub const DESTROY_REGION_REQUEST: u8 = 10; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyRegionRequest { + pub region: Region, +} +impl DestroyRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let region_bytes = self.region.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_REGION_REQUEST, + 0, + 0, + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_region(conn: &Conn, region: Region) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let region_bytes = region.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_REGION_REQUEST, - 0, - 0, - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyRegionRequest { + region, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetRegion request pub const SET_REGION_REQUEST: u8 = 11; -pub fn set_region<'c, Conn>(conn: &'c Conn, region: Region, rectangles: &[xproto::Rectangle]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetRegionRequest<'input> { + pub region: Region, + pub rectangles: &'input [xproto::Rectangle], +} +impl<'input> SetRegionRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let region_bytes = self.region.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_REGION_REQUEST, + 0, + 0, + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let rectangles_bytes = self.rectangles.serialize(); + let length_so_far = length_so_far + rectangles_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), rectangles_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_region<'c, 'input, Conn>(conn: &'c Conn, region: Region, rectangles: &'input [xproto::Rectangle]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let region_bytes = region.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_REGION_REQUEST, - 0, - 0, - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let rectangles_bytes = rectangles.serialize(); - let length_so_far = length_so_far + rectangles_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&rectangles_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetRegionRequest { + region, + rectangles, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CopyRegion request pub const COPY_REGION_REQUEST: u8 = 12; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CopyRegionRequest { + pub source: Region, + pub destination: Region, +} +impl CopyRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let source_bytes = self.source.serialize(); + let destination_bytes = self.destination.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + COPY_REGION_REQUEST, + 0, + 0, + source_bytes[0], + source_bytes[1], + source_bytes[2], + source_bytes[3], + destination_bytes[0], + destination_bytes[1], + destination_bytes[2], + destination_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn copy_region(conn: &Conn, source: Region, destination: Region) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let source_bytes = source.serialize(); - let destination_bytes = destination.serialize(); - let mut request0 = [ - extension_information.major_opcode, - COPY_REGION_REQUEST, - 0, - 0, - source_bytes[0], - source_bytes[1], - source_bytes[2], - source_bytes[3], - destination_bytes[0], - destination_bytes[1], - destination_bytes[2], - destination_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CopyRegionRequest { + source, + destination, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UnionRegion request pub const UNION_REGION_REQUEST: u8 = 13; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UnionRegionRequest { + pub source1: Region, + pub source2: Region, + pub destination: Region, +} +impl UnionRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let source1_bytes = self.source1.serialize(); + let source2_bytes = self.source2.serialize(); + let destination_bytes = self.destination.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + UNION_REGION_REQUEST, + 0, + 0, + source1_bytes[0], + source1_bytes[1], + source1_bytes[2], + source1_bytes[3], + source2_bytes[0], + source2_bytes[1], + source2_bytes[2], + source2_bytes[3], + destination_bytes[0], + destination_bytes[1], + destination_bytes[2], + destination_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn union_region(conn: &Conn, source1: Region, source2: Region, destination: Region) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let source1_bytes = source1.serialize(); - let source2_bytes = source2.serialize(); - let destination_bytes = destination.serialize(); - let mut request0 = [ - extension_information.major_opcode, - UNION_REGION_REQUEST, - 0, - 0, - source1_bytes[0], - source1_bytes[1], - source1_bytes[2], - source1_bytes[3], - source2_bytes[0], - source2_bytes[1], - source2_bytes[2], - source2_bytes[3], - destination_bytes[0], - destination_bytes[1], - destination_bytes[2], - destination_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UnionRegionRequest { + source1, + source2, + destination, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the IntersectRegion request pub const INTERSECT_REGION_REQUEST: u8 = 14; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct IntersectRegionRequest { + pub source1: Region, + pub source2: Region, + pub destination: Region, +} +impl IntersectRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let source1_bytes = self.source1.serialize(); + let source2_bytes = self.source2.serialize(); + let destination_bytes = self.destination.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + INTERSECT_REGION_REQUEST, + 0, + 0, + source1_bytes[0], + source1_bytes[1], + source1_bytes[2], + source1_bytes[3], + source2_bytes[0], + source2_bytes[1], + source2_bytes[2], + source2_bytes[3], + destination_bytes[0], + destination_bytes[1], + destination_bytes[2], + destination_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn intersect_region(conn: &Conn, source1: Region, source2: Region, destination: Region) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let source1_bytes = source1.serialize(); - let source2_bytes = source2.serialize(); - let destination_bytes = destination.serialize(); - let mut request0 = [ - extension_information.major_opcode, - INTERSECT_REGION_REQUEST, - 0, - 0, - source1_bytes[0], - source1_bytes[1], - source1_bytes[2], - source1_bytes[3], - source2_bytes[0], - source2_bytes[1], - source2_bytes[2], - source2_bytes[3], - destination_bytes[0], - destination_bytes[1], - destination_bytes[2], - destination_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = IntersectRegionRequest { + source1, + source2, + destination, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SubtractRegion request pub const SUBTRACT_REGION_REQUEST: u8 = 15; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SubtractRegionRequest { + pub source1: Region, + pub source2: Region, + pub destination: Region, +} +impl SubtractRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let source1_bytes = self.source1.serialize(); + let source2_bytes = self.source2.serialize(); + let destination_bytes = self.destination.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SUBTRACT_REGION_REQUEST, + 0, + 0, + source1_bytes[0], + source1_bytes[1], + source1_bytes[2], + source1_bytes[3], + source2_bytes[0], + source2_bytes[1], + source2_bytes[2], + source2_bytes[3], + destination_bytes[0], + destination_bytes[1], + destination_bytes[2], + destination_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn subtract_region(conn: &Conn, source1: Region, source2: Region, destination: Region) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let source1_bytes = source1.serialize(); - let source2_bytes = source2.serialize(); - let destination_bytes = destination.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SUBTRACT_REGION_REQUEST, - 0, - 0, - source1_bytes[0], - source1_bytes[1], - source1_bytes[2], - source1_bytes[3], - source2_bytes[0], - source2_bytes[1], - source2_bytes[2], - source2_bytes[3], - destination_bytes[0], - destination_bytes[1], - destination_bytes[2], - destination_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SubtractRegionRequest { + source1, + source2, + destination, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the InvertRegion request pub const INVERT_REGION_REQUEST: u8 = 16; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct InvertRegionRequest { + pub source: Region, + pub bounds: xproto::Rectangle, + pub destination: Region, +} +impl InvertRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let source_bytes = self.source.serialize(); + let bounds_bytes = self.bounds.serialize(); + let destination_bytes = self.destination.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + INVERT_REGION_REQUEST, + 0, + 0, + source_bytes[0], + source_bytes[1], + source_bytes[2], + source_bytes[3], + bounds_bytes[0], + bounds_bytes[1], + bounds_bytes[2], + bounds_bytes[3], + bounds_bytes[4], + bounds_bytes[5], + bounds_bytes[6], + bounds_bytes[7], + destination_bytes[0], + destination_bytes[1], + destination_bytes[2], + destination_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn invert_region(conn: &Conn, source: Region, bounds: xproto::Rectangle, destination: Region) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let source_bytes = source.serialize(); - let bounds_bytes = bounds.serialize(); - let destination_bytes = destination.serialize(); - let mut request0 = [ - extension_information.major_opcode, - INVERT_REGION_REQUEST, - 0, - 0, - source_bytes[0], - source_bytes[1], - source_bytes[2], - source_bytes[3], - bounds_bytes[0], - bounds_bytes[1], - bounds_bytes[2], - bounds_bytes[3], - bounds_bytes[4], - bounds_bytes[5], - bounds_bytes[6], - bounds_bytes[7], - destination_bytes[0], - destination_bytes[1], - destination_bytes[2], - destination_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = InvertRegionRequest { + source, + bounds, + destination, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the TranslateRegion request pub const TRANSLATE_REGION_REQUEST: u8 = 17; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct TranslateRegionRequest { + pub region: Region, + pub dx: i16, + pub dy: i16, +} +impl TranslateRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let region_bytes = self.region.serialize(); + let dx_bytes = self.dx.serialize(); + let dy_bytes = self.dy.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + TRANSLATE_REGION_REQUEST, + 0, + 0, + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + dx_bytes[0], + dx_bytes[1], + dy_bytes[0], + dy_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn translate_region(conn: &Conn, region: Region, dx: i16, dy: i16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let region_bytes = region.serialize(); - let dx_bytes = dx.serialize(); - let dy_bytes = dy.serialize(); - let mut request0 = [ - extension_information.major_opcode, - TRANSLATE_REGION_REQUEST, - 0, - 0, - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - dx_bytes[0], - dx_bytes[1], - dy_bytes[0], - dy_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = TranslateRegionRequest { + region, + dx, + dy, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the RegionExtents request pub const REGION_EXTENTS_REQUEST: u8 = 18; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct RegionExtentsRequest { + pub source: Region, + pub destination: Region, +} +impl RegionExtentsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let source_bytes = self.source.serialize(); + let destination_bytes = self.destination.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + REGION_EXTENTS_REQUEST, + 0, + 0, + source_bytes[0], + source_bytes[1], + source_bytes[2], + source_bytes[3], + destination_bytes[0], + destination_bytes[1], + destination_bytes[2], + destination_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn region_extents(conn: &Conn, source: Region, destination: Region) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let source_bytes = source.serialize(); - let destination_bytes = destination.serialize(); - let mut request0 = [ - extension_information.major_opcode, - REGION_EXTENTS_REQUEST, - 0, - 0, - source_bytes[0], - source_bytes[1], - source_bytes[2], - source_bytes[3], - destination_bytes[0], - destination_bytes[1], - destination_bytes[2], - destination_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = RegionExtentsRequest { + source, + destination, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the FetchRegion request pub const FETCH_REGION_REQUEST: u8 = 19; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FetchRegionRequest { + pub region: Region, +} +impl FetchRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let region_bytes = self.region.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FETCH_REGION_REQUEST, + 0, + 0, + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn fetch_region(conn: &Conn, region: Region) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let region_bytes = region.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FETCH_REGION_REQUEST, - 0, - 0, - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FetchRegionRequest { + region, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1570,190 +1978,302 @@ impl FetchRegionReply { /// Opcode for the SetGCClipRegion request pub const SET_GC_CLIP_REGION_REQUEST: u8 = 20; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetGCClipRegionRequest { + pub gc: xproto::Gcontext, + pub region: Region, + pub x_origin: i16, + pub y_origin: i16, +} +impl SetGCClipRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let gc_bytes = self.gc.serialize(); + let region_bytes = self.region.serialize(); + let x_origin_bytes = self.x_origin.serialize(); + let y_origin_bytes = self.y_origin.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_GC_CLIP_REGION_REQUEST, + 0, + 0, + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + x_origin_bytes[0], + x_origin_bytes[1], + y_origin_bytes[0], + y_origin_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_gc_clip_region(conn: &Conn, gc: xproto::Gcontext, region: A, x_origin: i16, y_origin: i16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let region: Region = region.into(); - let length_so_far = 0; - let gc_bytes = gc.serialize(); - let region_bytes = region.serialize(); - let x_origin_bytes = x_origin.serialize(); - let y_origin_bytes = y_origin.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_GC_CLIP_REGION_REQUEST, - 0, - 0, - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - x_origin_bytes[0], - x_origin_bytes[1], - y_origin_bytes[0], - y_origin_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetGCClipRegionRequest { + gc, + region, + x_origin, + y_origin, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetWindowShapeRegion request pub const SET_WINDOW_SHAPE_REGION_REQUEST: u8 = 21; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetWindowShapeRegionRequest { + pub dest: xproto::Window, + pub dest_kind: shape::SK, + pub x_offset: i16, + pub y_offset: i16, + pub region: Region, +} +impl SetWindowShapeRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let dest_bytes = self.dest.serialize(); + let dest_kind_bytes = shape::Kind::from(self.dest_kind).serialize(); + let x_offset_bytes = self.x_offset.serialize(); + let y_offset_bytes = self.y_offset.serialize(); + let region_bytes = self.region.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_WINDOW_SHAPE_REGION_REQUEST, + 0, + 0, + dest_bytes[0], + dest_bytes[1], + dest_bytes[2], + dest_bytes[3], + dest_kind_bytes[0], + 0, + 0, + 0, + x_offset_bytes[0], + x_offset_bytes[1], + y_offset_bytes[0], + y_offset_bytes[1], + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_window_shape_region(conn: &Conn, dest: xproto::Window, dest_kind: shape::SK, x_offset: i16, y_offset: i16, region: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let region: Region = region.into(); - let length_so_far = 0; - let dest_bytes = dest.serialize(); - let dest_kind_bytes = shape::Kind::from(dest_kind).serialize(); - let x_offset_bytes = x_offset.serialize(); - let y_offset_bytes = y_offset.serialize(); - let region_bytes = region.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_WINDOW_SHAPE_REGION_REQUEST, - 0, - 0, - dest_bytes[0], - dest_bytes[1], - dest_bytes[2], - dest_bytes[3], - dest_kind_bytes[0], - 0, - 0, - 0, - x_offset_bytes[0], - x_offset_bytes[1], - y_offset_bytes[0], - y_offset_bytes[1], - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetWindowShapeRegionRequest { + dest, + dest_kind, + x_offset, + y_offset, + region, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetPictureClipRegion request pub const SET_PICTURE_CLIP_REGION_REQUEST: u8 = 22; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetPictureClipRegionRequest { + pub picture: render::Picture, + pub region: Region, + pub x_origin: i16, + pub y_origin: i16, +} +impl SetPictureClipRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let picture_bytes = self.picture.serialize(); + let region_bytes = self.region.serialize(); + let x_origin_bytes = self.x_origin.serialize(); + let y_origin_bytes = self.y_origin.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PICTURE_CLIP_REGION_REQUEST, + 0, + 0, + picture_bytes[0], + picture_bytes[1], + picture_bytes[2], + picture_bytes[3], + region_bytes[0], + region_bytes[1], + region_bytes[2], + region_bytes[3], + x_origin_bytes[0], + x_origin_bytes[1], + y_origin_bytes[0], + y_origin_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_picture_clip_region(conn: &Conn, picture: render::Picture, region: A, x_origin: i16, y_origin: i16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let region: Region = region.into(); - let length_so_far = 0; - let picture_bytes = picture.serialize(); - let region_bytes = region.serialize(); - let x_origin_bytes = x_origin.serialize(); - let y_origin_bytes = y_origin.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PICTURE_CLIP_REGION_REQUEST, - 0, - 0, - picture_bytes[0], - picture_bytes[1], - picture_bytes[2], - picture_bytes[3], - region_bytes[0], - region_bytes[1], - region_bytes[2], - region_bytes[3], - x_origin_bytes[0], - x_origin_bytes[1], - y_origin_bytes[0], - y_origin_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetPictureClipRegionRequest { + picture, + region, + x_origin, + y_origin, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetCursorName request pub const SET_CURSOR_NAME_REQUEST: u8 = 23; -pub fn set_cursor_name<'c, Conn>(conn: &'c Conn, cursor: xproto::Cursor, name: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetCursorNameRequest<'input> { + pub cursor: xproto::Cursor, + pub name: &'input [u8], +} +impl<'input> SetCursorNameRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let cursor_bytes = self.cursor.serialize(); + let nbytes = u16::try_from(self.name.len()).expect("`name` has too many elements"); + let nbytes_bytes = nbytes.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_CURSOR_NAME_REQUEST, + 0, + 0, + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + nbytes_bytes[0], + nbytes_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_cursor_name<'c, 'input, Conn>(conn: &'c Conn, cursor: xproto::Cursor, name: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let cursor_bytes = cursor.serialize(); - let nbytes = u16::try_from(name.len()).expect("`name` has too many elements"); - let nbytes_bytes = nbytes.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_CURSOR_NAME_REQUEST, - 0, - 0, - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - nbytes_bytes[0], - nbytes_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) + let request0 = SetCursorNameRequest { + cursor, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetCursorName request pub const GET_CURSOR_NAME_REQUEST: u8 = 24; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetCursorNameRequest { + pub cursor: xproto::Cursor, +} +impl GetCursorNameRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let cursor_bytes = self.cursor.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CURSOR_NAME_REQUEST, + 0, + 0, + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_cursor_name(conn: &Conn, cursor: xproto::Cursor) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let cursor_bytes = cursor.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CURSOR_NAME_REQUEST, - 0, - 0, - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetCursorNameRequest { + cursor, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1803,24 +2323,38 @@ impl GetCursorNameReply { /// Opcode for the GetCursorImageAndName request pub const GET_CURSOR_IMAGE_AND_NAME_REQUEST: u8 = 25; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetCursorImageAndNameRequest; +impl GetCursorImageAndNameRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + GET_CURSOR_IMAGE_AND_NAME_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_cursor_image_and_name(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - GET_CURSOR_IMAGE_AND_NAME_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetCursorImageAndNameRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1886,168 +2420,272 @@ impl GetCursorImageAndNameReply { /// Opcode for the ChangeCursor request pub const CHANGE_CURSOR_REQUEST: u8 = 26; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangeCursorRequest { + pub source: xproto::Cursor, + pub destination: xproto::Cursor, +} +impl ChangeCursorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let source_bytes = self.source.serialize(); + let destination_bytes = self.destination.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_CURSOR_REQUEST, + 0, + 0, + source_bytes[0], + source_bytes[1], + source_bytes[2], + source_bytes[3], + destination_bytes[0], + destination_bytes[1], + destination_bytes[2], + destination_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn change_cursor(conn: &Conn, source: xproto::Cursor, destination: xproto::Cursor) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let source_bytes = source.serialize(); - let destination_bytes = destination.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_CURSOR_REQUEST, - 0, - 0, - source_bytes[0], - source_bytes[1], - source_bytes[2], - source_bytes[3], - destination_bytes[0], - destination_bytes[1], - destination_bytes[2], - destination_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ChangeCursorRequest { + source, + destination, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ChangeCursorByName request pub const CHANGE_CURSOR_BY_NAME_REQUEST: u8 = 27; -pub fn change_cursor_by_name<'c, Conn>(conn: &'c Conn, src: xproto::Cursor, name: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeCursorByNameRequest<'input> { + pub src: xproto::Cursor, + pub name: &'input [u8], +} +impl<'input> ChangeCursorByNameRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let src_bytes = self.src.serialize(); + let nbytes = u16::try_from(self.name.len()).expect("`name` has too many elements"); + let nbytes_bytes = nbytes.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_CURSOR_BY_NAME_REQUEST, + 0, + 0, + src_bytes[0], + src_bytes[1], + src_bytes[2], + src_bytes[3], + nbytes_bytes[0], + nbytes_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) + } +} +pub fn change_cursor_by_name<'c, 'input, Conn>(conn: &'c Conn, src: xproto::Cursor, name: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let src_bytes = src.serialize(); - let nbytes = u16::try_from(name.len()).expect("`name` has too many elements"); - let nbytes_bytes = nbytes.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_CURSOR_BY_NAME_REQUEST, - 0, - 0, - src_bytes[0], - src_bytes[1], - src_bytes[2], - src_bytes[3], - nbytes_bytes[0], - nbytes_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeCursorByNameRequest { + src, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ExpandRegion request pub const EXPAND_REGION_REQUEST: u8 = 28; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ExpandRegionRequest { + pub source: Region, + pub destination: Region, + pub left: u16, + pub right: u16, + pub top: u16, + pub bottom: u16, +} +impl ExpandRegionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let source_bytes = self.source.serialize(); + let destination_bytes = self.destination.serialize(); + let left_bytes = self.left.serialize(); + let right_bytes = self.right.serialize(); + let top_bytes = self.top.serialize(); + let bottom_bytes = self.bottom.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + EXPAND_REGION_REQUEST, + 0, + 0, + source_bytes[0], + source_bytes[1], + source_bytes[2], + source_bytes[3], + destination_bytes[0], + destination_bytes[1], + destination_bytes[2], + destination_bytes[3], + left_bytes[0], + left_bytes[1], + right_bytes[0], + right_bytes[1], + top_bytes[0], + top_bytes[1], + bottom_bytes[0], + bottom_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn expand_region(conn: &Conn, source: Region, destination: Region, left: u16, right: u16, top: u16, bottom: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let source_bytes = source.serialize(); - let destination_bytes = destination.serialize(); - let left_bytes = left.serialize(); - let right_bytes = right.serialize(); - let top_bytes = top.serialize(); - let bottom_bytes = bottom.serialize(); - let mut request0 = [ - extension_information.major_opcode, - EXPAND_REGION_REQUEST, - 0, - 0, - source_bytes[0], - source_bytes[1], - source_bytes[2], - source_bytes[3], - destination_bytes[0], - destination_bytes[1], - destination_bytes[2], - destination_bytes[3], - left_bytes[0], - left_bytes[1], - right_bytes[0], - right_bytes[1], - top_bytes[0], - top_bytes[1], - bottom_bytes[0], - bottom_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ExpandRegionRequest { + source, + destination, + left, + right, + top, + bottom, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the HideCursor request pub const HIDE_CURSOR_REQUEST: u8 = 29; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct HideCursorRequest { + pub window: xproto::Window, +} +impl HideCursorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + HIDE_CURSOR_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn hide_cursor(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - HIDE_CURSOR_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = HideCursorRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ShowCursor request pub const SHOW_CURSOR_REQUEST: u8 = 30; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ShowCursorRequest { + pub window: xproto::Window, +} +impl ShowCursorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SHOW_CURSOR_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn show_cursor(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SHOW_CURSOR_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ShowCursorRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } pub type Barrier = u32; @@ -2123,90 +2761,140 @@ bitmask_binop!(BarrierDirections, u8); /// Opcode for the CreatePointerBarrier request pub const CREATE_POINTER_BARRIER_REQUEST: u8 = 31; -pub fn create_pointer_barrier<'c, Conn, A>(conn: &'c Conn, barrier: Barrier, window: xproto::Window, x1: u16, y1: u16, x2: u16, y2: u16, directions: A, devices: &[u16]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreatePointerBarrierRequest<'input> { + pub barrier: Barrier, + pub window: xproto::Window, + pub x1: u16, + pub y1: u16, + pub x2: u16, + pub y2: u16, + pub directions: u32, + pub devices: &'input [u16], +} +impl<'input> CreatePointerBarrierRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let barrier_bytes = self.barrier.serialize(); + let window_bytes = self.window.serialize(); + let x1_bytes = self.x1.serialize(); + let y1_bytes = self.y1.serialize(); + let x2_bytes = self.x2.serialize(); + let y2_bytes = self.y2.serialize(); + let directions_bytes = self.directions.serialize(); + let num_devices = u16::try_from(self.devices.len()).expect("`devices` has too many elements"); + let num_devices_bytes = num_devices.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_POINTER_BARRIER_REQUEST, + 0, + 0, + barrier_bytes[0], + barrier_bytes[1], + barrier_bytes[2], + barrier_bytes[3], + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + x1_bytes[0], + x1_bytes[1], + y1_bytes[0], + y1_bytes[1], + x2_bytes[0], + x2_bytes[1], + y2_bytes[0], + y2_bytes[1], + directions_bytes[0], + directions_bytes[1], + directions_bytes[2], + directions_bytes[3], + 0, + 0, + num_devices_bytes[0], + num_devices_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let devices_bytes = self.devices.serialize(); + let length_so_far = length_so_far + devices_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), devices_bytes.into(), padding0.into()], vec![])) + } +} +pub fn create_pointer_barrier<'c, 'input, Conn, A>(conn: &'c Conn, barrier: Barrier, window: xproto::Window, x1: u16, y1: u16, x2: u16, y2: u16, directions: A, devices: &'input [u16]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let directions: u32 = directions.into(); - let length_so_far = 0; - let barrier_bytes = barrier.serialize(); - let window_bytes = window.serialize(); - let x1_bytes = x1.serialize(); - let y1_bytes = y1.serialize(); - let x2_bytes = x2.serialize(); - let y2_bytes = y2.serialize(); - let directions_bytes = directions.serialize(); - let num_devices = u16::try_from(devices.len()).expect("`devices` has too many elements"); - let num_devices_bytes = num_devices.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_POINTER_BARRIER_REQUEST, - 0, - 0, - barrier_bytes[0], - barrier_bytes[1], - barrier_bytes[2], - barrier_bytes[3], - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - x1_bytes[0], - x1_bytes[1], - y1_bytes[0], - y1_bytes[1], - x2_bytes[0], - x2_bytes[1], - y2_bytes[0], - y2_bytes[1], - directions_bytes[0], - directions_bytes[1], - directions_bytes[2], - directions_bytes[3], - 0, - 0, - num_devices_bytes[0], - num_devices_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let devices_bytes = devices.serialize(); - let length_so_far = length_so_far + devices_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&devices_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreatePointerBarrierRequest { + barrier, + window, + x1, + y1, + x2, + y2, + directions, + devices, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeletePointerBarrier request pub const DELETE_POINTER_BARRIER_REQUEST: u8 = 32; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DeletePointerBarrierRequest { + pub barrier: Barrier, +} +impl DeletePointerBarrierRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let barrier_bytes = self.barrier.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_POINTER_BARRIER_REQUEST, + 0, + 0, + barrier_bytes[0], + barrier_bytes[1], + barrier_bytes[2], + barrier_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn delete_pointer_barrier(conn: &Conn, barrier: Barrier) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let barrier_bytes = barrier.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_POINTER_BARRIER_REQUEST, - 0, - 0, - barrier_bytes[0], - barrier_bytes[1], - barrier_bytes[2], - barrier_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DeletePointerBarrierRequest { + barrier, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Extension trait defining the requests of this extension. @@ -2235,7 +2923,7 @@ pub trait ConnectionExt: RequestConnection { { get_cursor_image(self) } - fn xfixes_create_region<'c>(&'c self, region: Region, rectangles: &[xproto::Rectangle]) -> Result, ConnectionError> + fn xfixes_create_region<'c, 'input>(&'c self, region: Region, rectangles: &'input [xproto::Rectangle]) -> Result, ConnectionError> { create_region(self, region, rectangles) } @@ -2259,7 +2947,7 @@ pub trait ConnectionExt: RequestConnection { { destroy_region(self, region) } - fn xfixes_set_region<'c>(&'c self, region: Region, rectangles: &[xproto::Rectangle]) -> Result, ConnectionError> + fn xfixes_set_region<'c, 'input>(&'c self, region: Region, rectangles: &'input [xproto::Rectangle]) -> Result, ConnectionError> { set_region(self, region, rectangles) } @@ -2313,7 +3001,7 @@ pub trait ConnectionExt: RequestConnection { { set_picture_clip_region(self, picture, region, x_origin, y_origin) } - fn xfixes_set_cursor_name<'c>(&'c self, cursor: xproto::Cursor, name: &[u8]) -> Result, ConnectionError> + fn xfixes_set_cursor_name<'c, 'input>(&'c self, cursor: xproto::Cursor, name: &'input [u8]) -> Result, ConnectionError> { set_cursor_name(self, cursor, name) } @@ -2329,7 +3017,7 @@ pub trait ConnectionExt: RequestConnection { { change_cursor(self, source, destination) } - fn xfixes_change_cursor_by_name<'c>(&'c self, src: xproto::Cursor, name: &[u8]) -> Result, ConnectionError> + fn xfixes_change_cursor_by_name<'c, 'input>(&'c self, src: xproto::Cursor, name: &'input [u8]) -> Result, ConnectionError> { change_cursor_by_name(self, src, name) } @@ -2345,7 +3033,7 @@ pub trait ConnectionExt: RequestConnection { { show_cursor(self, window) } - fn xfixes_create_pointer_barrier<'c, A>(&'c self, barrier: Barrier, window: xproto::Window, x1: u16, y1: u16, x2: u16, y2: u16, directions: A, devices: &[u16]) -> Result, ConnectionError> + fn xfixes_create_pointer_barrier<'c, 'input, A>(&'c self, barrier: Barrier, window: xproto::Window, x1: u16, y1: u16, x2: u16, y2: u16, directions: A, devices: &'input [u16]) -> Result, ConnectionError> where A: Into, { diff --git a/src/protocol/xinerama.rs b/src/protocol/xinerama.rs index 0c769b51..4c9fa2f8 100644 --- a/src/protocol/xinerama.rs +++ b/src/protocol/xinerama.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -85,30 +85,50 @@ impl Serialize for ScreenInfo { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub major: u8, + pub minor: u8, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_bytes = self.major.serialize(); + let minor_bytes = self.minor.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + major_bytes[0], + minor_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, major: u8, minor: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_bytes = major.serialize(); - let minor_bytes = minor.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - major_bytes[0], - minor_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + major, + minor, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -140,29 +160,47 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the GetState request pub const GET_STATE_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetStateRequest { + pub window: xproto::Window, +} +impl GetStateRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_STATE_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_state(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_STATE_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetStateRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -193,29 +231,47 @@ impl TryFrom<&[u8]> for GetStateReply { /// Opcode for the GetScreenCount request pub const GET_SCREEN_COUNT_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetScreenCountRequest { + pub window: xproto::Window, +} +impl GetScreenCountRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SCREEN_COUNT_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_screen_count(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SCREEN_COUNT_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetScreenCountRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -246,34 +302,54 @@ impl TryFrom<&[u8]> for GetScreenCountReply { /// Opcode for the GetScreenSize request pub const GET_SCREEN_SIZE_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetScreenSizeRequest { + pub window: xproto::Window, + pub screen: u32, +} +impl GetScreenSizeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let screen_bytes = self.screen.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SCREEN_SIZE_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + screen_bytes[0], + screen_bytes[1], + screen_bytes[2], + screen_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_screen_size(conn: &Conn, window: xproto::Window, screen: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let screen_bytes = screen.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SCREEN_SIZE_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - screen_bytes[0], - screen_bytes[1], - screen_bytes[2], - screen_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetScreenSizeRequest { + window, + screen, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -309,24 +385,38 @@ impl TryFrom<&[u8]> for GetScreenSizeReply { /// Opcode for the IsActive request pub const IS_ACTIVE_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct IsActiveRequest; +impl IsActiveRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + IS_ACTIVE_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn is_active(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - IS_ACTIVE_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = IsActiveRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -356,24 +446,38 @@ impl TryFrom<&[u8]> for IsActiveReply { /// Opcode for the QueryScreens request pub const QUERY_SCREENS_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryScreensRequest; +impl QueryScreensRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_SCREENS_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_screens(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - QUERY_SCREENS_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryScreensRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/src/protocol/xinput.rs b/src/protocol/xinput.rs index 6c8bd47c..bcc6e49c 100644 --- a/src/protocol/xinput.rs +++ b/src/protocol/xinput.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -86,33 +86,51 @@ impl Serialize for Fp3232 { /// Opcode for the GetExtensionVersion request pub const GET_EXTENSION_VERSION_REQUEST: u8 = 1; -pub fn get_extension_version<'c, Conn>(conn: &'c Conn, name: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct GetExtensionVersionRequest<'input> { + pub name: &'input [u8], +} +impl<'input> GetExtensionVersionRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let name_len = u16::try_from(self.name.len()).expect("`name` has too many elements"); + let name_len_bytes = name_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_EXTENSION_VERSION_REQUEST, + 0, + 0, + name_len_bytes[0], + name_len_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) + } +} +pub fn get_extension_version<'c, 'input, Conn>(conn: &'c Conn, name: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let name_len = u16::try_from(name.len()).expect("`name` has too many elements"); - let name_len_bytes = name_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_EXTENSION_VERSION_REQUEST, - 0, - 0, - name_len_bytes[0], - name_len_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) + let request0 = GetExtensionVersionRequest { + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -926,24 +944,38 @@ impl DeviceName { /// Opcode for the ListInputDevices request pub const LIST_INPUT_DEVICES_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListInputDevicesRequest; +impl ListInputDevicesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + LIST_INPUT_DEVICES_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_input_devices(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - LIST_INPUT_DEVICES_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListInputDevicesRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1039,29 +1071,47 @@ impl Serialize for InputClassInfo { /// Opcode for the OpenDevice request pub const OPEN_DEVICE_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct OpenDeviceRequest { + pub device_id: u8, +} +impl OpenDeviceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + OPEN_DEVICE_REQUEST, + 0, + 0, + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn open_device(conn: &Conn, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - OPEN_DEVICE_REQUEST, - 0, - 0, - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = OpenDeviceRequest { + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1114,57 +1164,95 @@ impl OpenDeviceReply { /// Opcode for the CloseDevice request pub const CLOSE_DEVICE_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CloseDeviceRequest { + pub device_id: u8, +} +impl CloseDeviceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CLOSE_DEVICE_REQUEST, + 0, + 0, + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn close_device(conn: &Conn, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CLOSE_DEVICE_REQUEST, - 0, - 0, - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CloseDeviceRequest { + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetDeviceMode request pub const SET_DEVICE_MODE_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetDeviceModeRequest { + pub device_id: u8, + pub mode: ValuatorMode, +} +impl SetDeviceModeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let mode_bytes = u8::from(self.mode).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_DEVICE_MODE_REQUEST, + 0, + 0, + device_id_bytes[0], + mode_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_device_mode(conn: &Conn, device_id: u8, mode: ValuatorMode) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let mode_bytes = u8::from(mode).serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_DEVICE_MODE_REQUEST, - 0, - 0, - device_id_bytes[0], - mode_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetDeviceModeRequest { + device_id, + mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1197,66 +1285,104 @@ impl TryFrom<&[u8]> for SetDeviceModeReply { /// Opcode for the SelectExtensionEvent request pub const SELECT_EXTENSION_EVENT_REQUEST: u8 = 6; -pub fn select_extension_event<'c, Conn>(conn: &'c Conn, window: xproto::Window, classes: &[EventClass]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SelectExtensionEventRequest<'input> { + pub window: xproto::Window, + pub classes: &'input [EventClass], +} +impl<'input> SelectExtensionEventRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let num_classes = u16::try_from(self.classes.len()).expect("`classes` has too many elements"); + let num_classes_bytes = num_classes.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_EXTENSION_EVENT_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + num_classes_bytes[0], + num_classes_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let classes_bytes = self.classes.serialize(); + let length_so_far = length_so_far + classes_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), classes_bytes.into(), padding0.into()], vec![])) + } +} +pub fn select_extension_event<'c, 'input, Conn>(conn: &'c Conn, window: xproto::Window, classes: &'input [EventClass]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let num_classes = u16::try_from(classes.len()).expect("`classes` has too many elements"); - let num_classes_bytes = num_classes.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_EXTENSION_EVENT_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - num_classes_bytes[0], - num_classes_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let classes_bytes = classes.serialize(); - let length_so_far = length_so_far + classes_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&classes_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SelectExtensionEventRequest { + window, + classes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetSelectedExtensionEvents request pub const GET_SELECTED_EXTENSION_EVENTS_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetSelectedExtensionEventsRequest { + pub window: xproto::Window, +} +impl GetSelectedExtensionEventsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SELECTED_EXTENSION_EVENTS_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_selected_extension_events(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SELECTED_EXTENSION_EVENTS_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetSelectedExtensionEventsRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1390,67 +1516,107 @@ impl TryFrom for PropagateMode { /// Opcode for the ChangeDeviceDontPropagateList request pub const CHANGE_DEVICE_DONT_PROPAGATE_LIST_REQUEST: u8 = 8; -pub fn change_device_dont_propagate_list<'c, Conn>(conn: &'c Conn, window: xproto::Window, mode: PropagateMode, classes: &[EventClass]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeDeviceDontPropagateListRequest<'input> { + pub window: xproto::Window, + pub mode: PropagateMode, + pub classes: &'input [EventClass], +} +impl<'input> ChangeDeviceDontPropagateListRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let num_classes = u16::try_from(self.classes.len()).expect("`classes` has too many elements"); + let num_classes_bytes = num_classes.serialize(); + let mode_bytes = u8::from(self.mode).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_DEVICE_DONT_PROPAGATE_LIST_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + num_classes_bytes[0], + num_classes_bytes[1], + mode_bytes[0], + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let classes_bytes = self.classes.serialize(); + let length_so_far = length_so_far + classes_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), classes_bytes.into(), padding0.into()], vec![])) + } +} +pub fn change_device_dont_propagate_list<'c, 'input, Conn>(conn: &'c Conn, window: xproto::Window, mode: PropagateMode, classes: &'input [EventClass]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let num_classes = u16::try_from(classes.len()).expect("`classes` has too many elements"); - let num_classes_bytes = num_classes.serialize(); - let mode_bytes = u8::from(mode).serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_DEVICE_DONT_PROPAGATE_LIST_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - num_classes_bytes[0], - num_classes_bytes[1], - mode_bytes[0], - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let classes_bytes = classes.serialize(); - let length_so_far = length_so_far + classes_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&classes_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeDeviceDontPropagateListRequest { + window, + mode, + classes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetDeviceDontPropagateList request pub const GET_DEVICE_DONT_PROPAGATE_LIST_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceDontPropagateListRequest { + pub window: xproto::Window, +} +impl GetDeviceDontPropagateListRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_DONT_PROPAGATE_LIST_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_dont_propagate_list(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_DONT_PROPAGATE_LIST_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceDontPropagateListRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1526,41 +1692,63 @@ impl DeviceTimeCoord { /// Opcode for the GetDeviceMotionEvents request pub const GET_DEVICE_MOTION_EVENTS_REQUEST: u8 = 10; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceMotionEventsRequest { + pub start: xproto::Timestamp, + pub stop: xproto::Timestamp, + pub device_id: u8, +} +impl GetDeviceMotionEventsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let start_bytes = self.start.serialize(); + let stop_bytes = self.stop.serialize(); + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_MOTION_EVENTS_REQUEST, + 0, + 0, + start_bytes[0], + start_bytes[1], + start_bytes[2], + start_bytes[3], + stop_bytes[0], + stop_bytes[1], + stop_bytes[2], + stop_bytes[3], + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_motion_events(conn: &Conn, start: xproto::Timestamp, stop: A, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let stop: xproto::Timestamp = stop.into(); - let length_so_far = 0; - let start_bytes = start.serialize(); - let stop_bytes = stop.serialize(); - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_MOTION_EVENTS_REQUEST, - 0, - 0, - start_bytes[0], - start_bytes[1], - start_bytes[2], - start_bytes[3], - stop_bytes[0], - stop_bytes[1], - stop_bytes[2], - stop_bytes[3], - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceMotionEventsRequest { + start, + stop, + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1620,29 +1808,47 @@ impl GetDeviceMotionEventsReply { /// Opcode for the ChangeKeyboardDevice request pub const CHANGE_KEYBOARD_DEVICE_REQUEST: u8 = 11; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangeKeyboardDeviceRequest { + pub device_id: u8, +} +impl ChangeKeyboardDeviceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_KEYBOARD_DEVICE_REQUEST, + 0, + 0, + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn change_keyboard_device(conn: &Conn, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_KEYBOARD_DEVICE_REQUEST, - 0, - 0, - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ChangeKeyboardDeviceRequest { + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1675,31 +1881,53 @@ impl TryFrom<&[u8]> for ChangeKeyboardDeviceReply { /// Opcode for the ChangePointerDevice request pub const CHANGE_POINTER_DEVICE_REQUEST: u8 = 12; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangePointerDeviceRequest { + pub x_axis: u8, + pub y_axis: u8, + pub device_id: u8, +} +impl ChangePointerDeviceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let x_axis_bytes = self.x_axis.serialize(); + let y_axis_bytes = self.y_axis.serialize(); + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_POINTER_DEVICE_REQUEST, + 0, + 0, + x_axis_bytes[0], + y_axis_bytes[0], + device_id_bytes[0], + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn change_pointer_device(conn: &Conn, x_axis: u8, y_axis: u8, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let x_axis_bytes = x_axis.serialize(); - let y_axis_bytes = y_axis.serialize(); - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_POINTER_DEVICE_REQUEST, - 0, - 0, - x_axis_bytes[0], - y_axis_bytes[0], - device_id_bytes[0], - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ChangePointerDeviceRequest { + x_axis, + y_axis, + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1732,54 +1960,84 @@ impl TryFrom<&[u8]> for ChangePointerDeviceReply { /// Opcode for the GrabDevice request pub const GRAB_DEVICE_REQUEST: u8 = 13; -pub fn grab_device<'c, Conn, A>(conn: &'c Conn, grab_window: xproto::Window, time: A, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, device_id: u8, classes: &[EventClass]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct GrabDeviceRequest<'input> { + pub grab_window: xproto::Window, + pub time: xproto::Timestamp, + pub this_device_mode: xproto::GrabMode, + pub other_device_mode: xproto::GrabMode, + pub owner_events: bool, + pub device_id: u8, + pub classes: &'input [EventClass], +} +impl<'input> GrabDeviceRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let grab_window_bytes = self.grab_window.serialize(); + let time_bytes = self.time.serialize(); + let num_classes = u16::try_from(self.classes.len()).expect("`classes` has too many elements"); + let num_classes_bytes = num_classes.serialize(); + let this_device_mode_bytes = u8::from(self.this_device_mode).serialize(); + let other_device_mode_bytes = u8::from(self.other_device_mode).serialize(); + let owner_events_bytes = self.owner_events.serialize(); + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GRAB_DEVICE_REQUEST, + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + num_classes_bytes[0], + num_classes_bytes[1], + this_device_mode_bytes[0], + other_device_mode_bytes[0], + owner_events_bytes[0], + device_id_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let classes_bytes = self.classes.serialize(); + let length_so_far = length_so_far + classes_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), classes_bytes.into(), padding0.into()], vec![])) + } +} +pub fn grab_device<'c, 'input, Conn, A>(conn: &'c Conn, grab_window: xproto::Window, time: A, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, device_id: u8, classes: &'input [EventClass]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let time: xproto::Timestamp = time.into(); - let length_so_far = 0; - let grab_window_bytes = grab_window.serialize(); - let time_bytes = time.serialize(); - let num_classes = u16::try_from(classes.len()).expect("`classes` has too many elements"); - let num_classes_bytes = num_classes.serialize(); - let this_device_mode_bytes = u8::from(this_device_mode).serialize(); - let other_device_mode_bytes = u8::from(other_device_mode).serialize(); - let owner_events_bytes = owner_events.serialize(); - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GRAB_DEVICE_REQUEST, - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - num_classes_bytes[0], - num_classes_bytes[1], - this_device_mode_bytes[0], - other_device_mode_bytes[0], - owner_events_bytes[0], - device_id_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let classes_bytes = classes.serialize(); - let length_so_far = length_so_far + classes_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&classes_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = GrabDeviceRequest { + grab_window, + time, + this_device_mode, + other_device_mode, + owner_events, + device_id, + classes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1812,36 +2070,56 @@ impl TryFrom<&[u8]> for GrabDeviceReply { /// Opcode for the UngrabDevice request pub const UNGRAB_DEVICE_REQUEST: u8 = 14; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UngrabDeviceRequest { + pub time: xproto::Timestamp, + pub device_id: u8, +} +impl UngrabDeviceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let time_bytes = self.time.serialize(); + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + UNGRAB_DEVICE_REQUEST, + 0, + 0, + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn ungrab_device(conn: &Conn, time: A, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let time: xproto::Timestamp = time.into(); - let length_so_far = 0; - let time_bytes = time.serialize(); - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - UNGRAB_DEVICE_REQUEST, - 0, - 0, - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UngrabDeviceRequest { + time, + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1905,64 +2183,145 @@ impl TryFrom for ModifierDevice { /// Opcode for the GrabDeviceKey request pub const GRAB_DEVICE_KEY_REQUEST: u8 = 15; -pub fn grab_device_key<'c, Conn, A, B, C>(conn: &'c Conn, grab_window: xproto::Window, modifiers: A, modifier_device: B, grabbed_device: u8, key: C, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, classes: &[EventClass]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct GrabDeviceKeyRequest<'input> { + pub grab_window: xproto::Window, + pub modifiers: u16, + pub modifier_device: u8, + pub grabbed_device: u8, + pub key: u8, + pub this_device_mode: xproto::GrabMode, + pub other_device_mode: xproto::GrabMode, + pub owner_events: bool, + pub classes: &'input [EventClass], +} +impl<'input> GrabDeviceKeyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let grab_window_bytes = self.grab_window.serialize(); + let num_classes = u16::try_from(self.classes.len()).expect("`classes` has too many elements"); + let num_classes_bytes = num_classes.serialize(); + let modifiers_bytes = self.modifiers.serialize(); + let modifier_device_bytes = self.modifier_device.serialize(); + let grabbed_device_bytes = self.grabbed_device.serialize(); + let key_bytes = self.key.serialize(); + let this_device_mode_bytes = u8::from(self.this_device_mode).serialize(); + let other_device_mode_bytes = u8::from(self.other_device_mode).serialize(); + let owner_events_bytes = self.owner_events.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GRAB_DEVICE_KEY_REQUEST, + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + num_classes_bytes[0], + num_classes_bytes[1], + modifiers_bytes[0], + modifiers_bytes[1], + modifier_device_bytes[0], + grabbed_device_bytes[0], + key_bytes[0], + this_device_mode_bytes[0], + other_device_mode_bytes[0], + owner_events_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let classes_bytes = self.classes.serialize(); + let length_so_far = length_so_far + classes_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), classes_bytes.into(), padding0.into()], vec![])) + } +} +pub fn grab_device_key<'c, 'input, Conn, A, B, C>(conn: &'c Conn, grab_window: xproto::Window, modifiers: A, modifier_device: B, grabbed_device: u8, key: C, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, classes: &'input [EventClass]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, C: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let modifiers: u16 = modifiers.into(); let modifier_device: u8 = modifier_device.into(); let key: u8 = key.into(); - let length_so_far = 0; - let grab_window_bytes = grab_window.serialize(); - let num_classes = u16::try_from(classes.len()).expect("`classes` has too many elements"); - let num_classes_bytes = num_classes.serialize(); - let modifiers_bytes = modifiers.serialize(); - let modifier_device_bytes = modifier_device.serialize(); - let grabbed_device_bytes = grabbed_device.serialize(); - let key_bytes = key.serialize(); - let this_device_mode_bytes = u8::from(this_device_mode).serialize(); - let other_device_mode_bytes = u8::from(other_device_mode).serialize(); - let owner_events_bytes = owner_events.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GRAB_DEVICE_KEY_REQUEST, - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - num_classes_bytes[0], - num_classes_bytes[1], - modifiers_bytes[0], - modifiers_bytes[1], - modifier_device_bytes[0], - grabbed_device_bytes[0], - key_bytes[0], - this_device_mode_bytes[0], - other_device_mode_bytes[0], - owner_events_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let classes_bytes = classes.serialize(); - let length_so_far = length_so_far + classes_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&classes_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = GrabDeviceKeyRequest { + grab_window, + modifiers, + modifier_device, + grabbed_device, + key, + this_device_mode, + other_device_mode, + owner_events, + classes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UngrabDeviceKey request pub const UNGRAB_DEVICE_KEY_REQUEST: u8 = 16; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UngrabDeviceKeyRequest { + pub grab_window: xproto::Window, + pub modifiers: u16, + pub modifier_device: u8, + pub key: u8, + pub grabbed_device: u8, +} +impl UngrabDeviceKeyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let grab_window_bytes = self.grab_window.serialize(); + let modifiers_bytes = self.modifiers.serialize(); + let modifier_device_bytes = self.modifier_device.serialize(); + let key_bytes = self.key.serialize(); + let grabbed_device_bytes = self.grabbed_device.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + UNGRAB_DEVICE_KEY_REQUEST, + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + modifiers_bytes[0], + modifiers_bytes[1], + modifier_device_bytes[0], + key_bytes[0], + grabbed_device_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn ungrab_device_key(conn: &Conn, grab_window: xproto::Window, modifiers: A, modifier_device: B, key: C, grabbed_device: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -1970,102 +2329,162 @@ where B: Into, C: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let modifiers: u16 = modifiers.into(); let modifier_device: u8 = modifier_device.into(); let key: u8 = key.into(); - let length_so_far = 0; - let grab_window_bytes = grab_window.serialize(); - let modifiers_bytes = modifiers.serialize(); - let modifier_device_bytes = modifier_device.serialize(); - let key_bytes = key.serialize(); - let grabbed_device_bytes = grabbed_device.serialize(); - let mut request0 = [ - extension_information.major_opcode, - UNGRAB_DEVICE_KEY_REQUEST, - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - modifiers_bytes[0], - modifiers_bytes[1], - modifier_device_bytes[0], - key_bytes[0], - grabbed_device_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UngrabDeviceKeyRequest { + grab_window, + modifiers, + modifier_device, + key, + grabbed_device, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GrabDeviceButton request pub const GRAB_DEVICE_BUTTON_REQUEST: u8 = 17; -pub fn grab_device_button<'c, Conn, A, B, C>(conn: &'c Conn, grab_window: xproto::Window, grabbed_device: u8, modifier_device: A, modifiers: B, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, button: C, owner_events: bool, classes: &[EventClass]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct GrabDeviceButtonRequest<'input> { + pub grab_window: xproto::Window, + pub grabbed_device: u8, + pub modifier_device: u8, + pub modifiers: u16, + pub this_device_mode: xproto::GrabMode, + pub other_device_mode: xproto::GrabMode, + pub button: u8, + pub owner_events: bool, + pub classes: &'input [EventClass], +} +impl<'input> GrabDeviceButtonRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let grab_window_bytes = self.grab_window.serialize(); + let grabbed_device_bytes = self.grabbed_device.serialize(); + let modifier_device_bytes = self.modifier_device.serialize(); + let num_classes = u16::try_from(self.classes.len()).expect("`classes` has too many elements"); + let num_classes_bytes = num_classes.serialize(); + let modifiers_bytes = self.modifiers.serialize(); + let this_device_mode_bytes = u8::from(self.this_device_mode).serialize(); + let other_device_mode_bytes = u8::from(self.other_device_mode).serialize(); + let button_bytes = self.button.serialize(); + let owner_events_bytes = self.owner_events.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GRAB_DEVICE_BUTTON_REQUEST, + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + grabbed_device_bytes[0], + modifier_device_bytes[0], + num_classes_bytes[0], + num_classes_bytes[1], + modifiers_bytes[0], + modifiers_bytes[1], + this_device_mode_bytes[0], + other_device_mode_bytes[0], + button_bytes[0], + owner_events_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let classes_bytes = self.classes.serialize(); + let length_so_far = length_so_far + classes_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), classes_bytes.into(), padding0.into()], vec![])) + } +} +pub fn grab_device_button<'c, 'input, Conn, A, B, C>(conn: &'c Conn, grab_window: xproto::Window, grabbed_device: u8, modifier_device: A, modifiers: B, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, button: C, owner_events: bool, classes: &'input [EventClass]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, C: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let modifier_device: u8 = modifier_device.into(); let modifiers: u16 = modifiers.into(); let button: u8 = button.into(); - let length_so_far = 0; - let grab_window_bytes = grab_window.serialize(); - let grabbed_device_bytes = grabbed_device.serialize(); - let modifier_device_bytes = modifier_device.serialize(); - let num_classes = u16::try_from(classes.len()).expect("`classes` has too many elements"); - let num_classes_bytes = num_classes.serialize(); - let modifiers_bytes = modifiers.serialize(); - let this_device_mode_bytes = u8::from(this_device_mode).serialize(); - let other_device_mode_bytes = u8::from(other_device_mode).serialize(); - let button_bytes = button.serialize(); - let owner_events_bytes = owner_events.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GRAB_DEVICE_BUTTON_REQUEST, - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - grabbed_device_bytes[0], - modifier_device_bytes[0], - num_classes_bytes[0], - num_classes_bytes[1], - modifiers_bytes[0], - modifiers_bytes[1], - this_device_mode_bytes[0], - other_device_mode_bytes[0], - button_bytes[0], - owner_events_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let classes_bytes = classes.serialize(); - let length_so_far = length_so_far + classes_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&classes_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = GrabDeviceButtonRequest { + grab_window, + grabbed_device, + modifier_device, + modifiers, + this_device_mode, + other_device_mode, + button, + owner_events, + classes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UngrabDeviceButton request pub const UNGRAB_DEVICE_BUTTON_REQUEST: u8 = 18; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UngrabDeviceButtonRequest { + pub grab_window: xproto::Window, + pub modifiers: u16, + pub modifier_device: u8, + pub button: u8, + pub grabbed_device: u8, +} +impl UngrabDeviceButtonRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let grab_window_bytes = self.grab_window.serialize(); + let modifiers_bytes = self.modifiers.serialize(); + let modifier_device_bytes = self.modifier_device.serialize(); + let button_bytes = self.button.serialize(); + let grabbed_device_bytes = self.grabbed_device.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + UNGRAB_DEVICE_BUTTON_REQUEST, + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + modifiers_bytes[0], + modifiers_bytes[1], + modifier_device_bytes[0], + button_bytes[0], + grabbed_device_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn ungrab_device_button(conn: &Conn, grab_window: xproto::Window, modifiers: A, modifier_device: B, button: C, grabbed_device: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -2073,40 +2492,19 @@ where B: Into, C: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let modifiers: u16 = modifiers.into(); let modifier_device: u8 = modifier_device.into(); let button: u8 = button.into(); - let length_so_far = 0; - let grab_window_bytes = grab_window.serialize(); - let modifiers_bytes = modifiers.serialize(); - let modifier_device_bytes = modifier_device.serialize(); - let button_bytes = button.serialize(); - let grabbed_device_bytes = grabbed_device.serialize(); - let mut request0 = [ - extension_information.major_opcode, - UNGRAB_DEVICE_BUTTON_REQUEST, - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - modifiers_bytes[0], - modifiers_bytes[1], - modifier_device_bytes[0], - button_bytes[0], - grabbed_device_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UngrabDeviceButtonRequest { + grab_window, + modifiers, + modifier_device, + button, + grabbed_device, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -2185,64 +2583,104 @@ impl TryFrom for DeviceInputMode { /// Opcode for the AllowDeviceEvents request pub const ALLOW_DEVICE_EVENTS_REQUEST: u8 = 19; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AllowDeviceEventsRequest { + pub time: xproto::Timestamp, + pub mode: DeviceInputMode, + pub device_id: u8, +} +impl AllowDeviceEventsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let time_bytes = self.time.serialize(); + let mode_bytes = u8::from(self.mode).serialize(); + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + ALLOW_DEVICE_EVENTS_REQUEST, + 0, + 0, + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + mode_bytes[0], + device_id_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn allow_device_events(conn: &Conn, time: A, mode: DeviceInputMode, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let time: xproto::Timestamp = time.into(); - let length_so_far = 0; - let time_bytes = time.serialize(); - let mode_bytes = u8::from(mode).serialize(); - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - ALLOW_DEVICE_EVENTS_REQUEST, - 0, - 0, - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - mode_bytes[0], - device_id_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = AllowDeviceEventsRequest { + time, + mode, + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetDeviceFocus request pub const GET_DEVICE_FOCUS_REQUEST: u8 = 20; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceFocusRequest { + pub device_id: u8, +} +impl GetDeviceFocusRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_FOCUS_REQUEST, + 0, + 0, + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_focus(conn: &Conn, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_FOCUS_REQUEST, - 0, - 0, - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceFocusRequest { + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -2279,44 +2717,68 @@ impl TryFrom<&[u8]> for GetDeviceFocusReply { /// Opcode for the SetDeviceFocus request pub const SET_DEVICE_FOCUS_REQUEST: u8 = 21; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetDeviceFocusRequest { + pub focus: xproto::Window, + pub time: xproto::Timestamp, + pub revert_to: xproto::InputFocus, + pub device_id: u8, +} +impl SetDeviceFocusRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let focus_bytes = self.focus.serialize(); + let time_bytes = self.time.serialize(); + let revert_to_bytes = u8::from(self.revert_to).serialize(); + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_DEVICE_FOCUS_REQUEST, + 0, + 0, + focus_bytes[0], + focus_bytes[1], + focus_bytes[2], + focus_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + revert_to_bytes[0], + device_id_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_device_focus(conn: &Conn, focus: A, time: B, revert_to: xproto::InputFocus, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let focus: xproto::Window = focus.into(); let time: xproto::Timestamp = time.into(); - let length_so_far = 0; - let focus_bytes = focus.serialize(); - let time_bytes = time.serialize(); - let revert_to_bytes = u8::from(revert_to).serialize(); - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_DEVICE_FOCUS_REQUEST, - 0, - 0, - focus_bytes[0], - focus_bytes[1], - focus_bytes[2], - focus_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - revert_to_bytes[0], - device_id_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetDeviceFocusRequest { + focus, + time, + revert_to, + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -3342,29 +3804,47 @@ impl Serialize for FeedbackState { /// Opcode for the GetFeedbackControl request pub const GET_FEEDBACK_CONTROL_REQUEST: u8 = 22; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetFeedbackControlRequest { + pub device_id: u8, +} +impl GetFeedbackControlRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_FEEDBACK_CONTROL_REQUEST, + 0, + 0, + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_feedback_control(conn: &Conn, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_FEEDBACK_CONTROL_REQUEST, - 0, - 0, - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetFeedbackControlRequest { + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4319,70 +4799,116 @@ bitmask_binop!(ChangeFeedbackControlMask, u8); /// Opcode for the ChangeFeedbackControl request pub const CHANGE_FEEDBACK_CONTROL_REQUEST: u8 = 23; +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeFeedbackControlRequest { + pub mask: u32, + pub device_id: u8, + pub feedback_id: u8, + pub feedback: FeedbackCtl, +} +impl ChangeFeedbackControlRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mask_bytes = self.mask.serialize(); + let device_id_bytes = self.device_id.serialize(); + let feedback_id_bytes = self.feedback_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_FEEDBACK_CONTROL_REQUEST, + 0, + 0, + mask_bytes[0], + mask_bytes[1], + mask_bytes[2], + mask_bytes[3], + device_id_bytes[0], + feedback_id_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let feedback_bytes = self.feedback.serialize(); + let length_so_far = length_so_far + feedback_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), feedback_bytes.into(), padding0.into()], vec![])) + } +} pub fn change_feedback_control(conn: &Conn, mask: A, device_id: u8, feedback_id: u8, feedback: FeedbackCtl) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let mask: u32 = mask.into(); - let length_so_far = 0; - let mask_bytes = mask.serialize(); - let device_id_bytes = device_id.serialize(); - let feedback_id_bytes = feedback_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_FEEDBACK_CONTROL_REQUEST, - 0, - 0, - mask_bytes[0], - mask_bytes[1], - mask_bytes[2], - mask_bytes[3], - device_id_bytes[0], - feedback_id_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let feedback_bytes = feedback.serialize(); - let length_so_far = length_so_far + feedback_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&feedback_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeFeedbackControlRequest { + mask, + device_id, + feedback_id, + feedback, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetDeviceKeyMapping request pub const GET_DEVICE_KEY_MAPPING_REQUEST: u8 = 24; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceKeyMappingRequest { + pub device_id: u8, + pub first_keycode: KeyCode, + pub count: u8, +} +impl GetDeviceKeyMappingRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let first_keycode_bytes = self.first_keycode.serialize(); + let count_bytes = self.count.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_KEY_MAPPING_REQUEST, + 0, + 0, + device_id_bytes[0], + first_keycode_bytes[0], + count_bytes[0], + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_key_mapping(conn: &Conn, device_id: u8, first_keycode: KeyCode, count: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let first_keycode_bytes = first_keycode.serialize(); - let count_bytes = count.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_KEY_MAPPING_REQUEST, - 0, - 0, - device_id_bytes[0], - first_keycode_bytes[0], - count_bytes[0], - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceKeyMappingRequest { + device_id, + first_keycode, + count, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4430,64 +4956,108 @@ impl GetDeviceKeyMappingReply { /// Opcode for the ChangeDeviceKeyMapping request pub const CHANGE_DEVICE_KEY_MAPPING_REQUEST: u8 = 25; -pub fn change_device_key_mapping<'c, Conn>(conn: &'c Conn, device_id: u8, first_keycode: KeyCode, keysyms_per_keycode: u8, keycode_count: u8, keysyms: &[xproto::Keysym]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeDeviceKeyMappingRequest<'input> { + pub device_id: u8, + pub first_keycode: KeyCode, + pub keysyms_per_keycode: u8, + pub keycode_count: u8, + pub keysyms: &'input [xproto::Keysym], +} +impl<'input> ChangeDeviceKeyMappingRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let first_keycode_bytes = self.first_keycode.serialize(); + let keysyms_per_keycode_bytes = self.keysyms_per_keycode.serialize(); + let keycode_count_bytes = self.keycode_count.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_DEVICE_KEY_MAPPING_REQUEST, + 0, + 0, + device_id_bytes[0], + first_keycode_bytes[0], + keysyms_per_keycode_bytes[0], + keycode_count_bytes[0], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(self.keysyms.len(), usize::try_from(u32::from(self.keycode_count).checked_mul(u32::from(self.keysyms_per_keycode)).unwrap()).unwrap(), "`keysyms` has an incorrect length"); + let keysyms_bytes = self.keysyms.serialize(); + let length_so_far = length_so_far + keysyms_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), keysyms_bytes.into(), padding0.into()], vec![])) + } +} +pub fn change_device_key_mapping<'c, 'input, Conn>(conn: &'c Conn, device_id: u8, first_keycode: KeyCode, keysyms_per_keycode: u8, keycode_count: u8, keysyms: &'input [xproto::Keysym]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let first_keycode_bytes = first_keycode.serialize(); - let keysyms_per_keycode_bytes = keysyms_per_keycode.serialize(); - let keycode_count_bytes = keycode_count.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_DEVICE_KEY_MAPPING_REQUEST, - 0, - 0, - device_id_bytes[0], - first_keycode_bytes[0], - keysyms_per_keycode_bytes[0], - keycode_count_bytes[0], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(keysyms.len(), usize::try_from(u32::from(keycode_count).checked_mul(u32::from(keysyms_per_keycode)).unwrap()).unwrap(), "`keysyms` has an incorrect length"); - let keysyms_bytes = keysyms.serialize(); - let length_so_far = length_so_far + keysyms_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&keysyms_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeDeviceKeyMappingRequest { + device_id, + first_keycode, + keysyms_per_keycode, + keycode_count, + keysyms, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetDeviceModifierMapping request pub const GET_DEVICE_MODIFIER_MAPPING_REQUEST: u8 = 26; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceModifierMappingRequest { + pub device_id: u8, +} +impl GetDeviceModifierMappingRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_MODIFIER_MAPPING_REQUEST, + 0, + 0, + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_modifier_mapping(conn: &Conn, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_MODIFIER_MAPPING_REQUEST, - 0, - 0, - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceModifierMappingRequest { + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4537,35 +5107,55 @@ impl GetDeviceModifierMappingReply { /// Opcode for the SetDeviceModifierMapping request pub const SET_DEVICE_MODIFIER_MAPPING_REQUEST: u8 = 27; -pub fn set_device_modifier_mapping<'c, Conn>(conn: &'c Conn, device_id: u8, keymaps: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetDeviceModifierMappingRequest<'input> { + pub device_id: u8, + pub keymaps: &'input [u8], +} +impl<'input> SetDeviceModifierMappingRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + assert_eq!(self.keymaps.len() % 8, 0, "`keymaps` has an incorrect length, must be a multiple of 8"); + let keycodes_per_modifier = u8::try_from(self.keymaps.len() / 8).expect("`keymaps` has too many elements"); + let keycodes_per_modifier_bytes = keycodes_per_modifier.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_DEVICE_MODIFIER_MAPPING_REQUEST, + 0, + 0, + device_id_bytes[0], + keycodes_per_modifier_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.keymaps[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.keymaps[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_device_modifier_mapping<'c, 'input, Conn>(conn: &'c Conn, device_id: u8, keymaps: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - assert_eq!(keymaps.len() % 8, 0, "`keymaps` has an incorrect length, must be a multiple of 8"); - let keycodes_per_modifier = u8::try_from(keymaps.len() / 8).expect("`keymaps` has too many elements"); - let keycodes_per_modifier_bytes = keycodes_per_modifier.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_DEVICE_MODIFIER_MAPPING_REQUEST, - 0, - 0, - device_id_bytes[0], - keycodes_per_modifier_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + keymaps.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(keymaps), IoSlice::new(&padding0)], vec![])?) + let request0 = SetDeviceModifierMappingRequest { + device_id, + keymaps, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -4598,29 +5188,47 @@ impl TryFrom<&[u8]> for SetDeviceModifierMappingReply { /// Opcode for the GetDeviceButtonMapping request pub const GET_DEVICE_BUTTON_MAPPING_REQUEST: u8 = 28; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceButtonMappingRequest { + pub device_id: u8, +} +impl GetDeviceButtonMappingRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_BUTTON_MAPPING_REQUEST, + 0, + 0, + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_button_mapping(conn: &Conn, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_BUTTON_MAPPING_REQUEST, - 0, - 0, - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceButtonMappingRequest { + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -4674,34 +5282,54 @@ impl GetDeviceButtonMappingReply { /// Opcode for the SetDeviceButtonMapping request pub const SET_DEVICE_BUTTON_MAPPING_REQUEST: u8 = 29; -pub fn set_device_button_mapping<'c, Conn>(conn: &'c Conn, device_id: u8, map: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetDeviceButtonMappingRequest<'input> { + pub device_id: u8, + pub map: &'input [u8], +} +impl<'input> SetDeviceButtonMappingRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let map_size = u8::try_from(self.map.len()).expect("`map` has too many elements"); + let map_size_bytes = map_size.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_DEVICE_BUTTON_MAPPING_REQUEST, + 0, + 0, + device_id_bytes[0], + map_size_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.map[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.map[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_device_button_mapping<'c, 'input, Conn>(conn: &'c Conn, device_id: u8, map: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let map_size = u8::try_from(map.len()).expect("`map` has too many elements"); - let map_size_bytes = map_size.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_DEVICE_BUTTON_MAPPING_REQUEST, - 0, - 0, - device_id_bytes[0], - map_size_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + map.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(map), IoSlice::new(&padding0)], vec![])?) + let request0 = SetDeviceButtonMappingRequest { + device_id, + map, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -5321,29 +5949,47 @@ impl Serialize for InputState { /// Opcode for the QueryDeviceState request pub const QUERY_DEVICE_STATE_REQUEST: u8 = 30; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryDeviceStateRequest { + pub device_id: u8, +} +impl QueryDeviceStateRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_DEVICE_STATE_REQUEST, + 0, + 0, + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_device_state(conn: &Conn, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_DEVICE_STATE_REQUEST, - 0, - 0, - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryDeviceStateRequest { + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -5391,66 +6037,112 @@ impl QueryDeviceStateReply { /// Opcode for the DeviceBell request pub const DEVICE_BELL_REQUEST: u8 = 32; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DeviceBellRequest { + pub device_id: u8, + pub feedback_id: u8, + pub feedback_class: u8, + pub percent: i8, +} +impl DeviceBellRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let feedback_id_bytes = self.feedback_id.serialize(); + let feedback_class_bytes = self.feedback_class.serialize(); + let percent_bytes = self.percent.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DEVICE_BELL_REQUEST, + 0, + 0, + device_id_bytes[0], + feedback_id_bytes[0], + feedback_class_bytes[0], + percent_bytes[0], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn device_bell(conn: &Conn, device_id: u8, feedback_id: u8, feedback_class: u8, percent: i8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let feedback_id_bytes = feedback_id.serialize(); - let feedback_class_bytes = feedback_class.serialize(); - let percent_bytes = percent.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DEVICE_BELL_REQUEST, - 0, - 0, - device_id_bytes[0], - feedback_id_bytes[0], - feedback_class_bytes[0], - percent_bytes[0], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DeviceBellRequest { + device_id, + feedback_id, + feedback_class, + percent, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetDeviceValuators request pub const SET_DEVICE_VALUATORS_REQUEST: u8 = 33; -pub fn set_device_valuators<'c, Conn>(conn: &'c Conn, device_id: u8, first_valuator: u8, valuators: &[i32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetDeviceValuatorsRequest<'input> { + pub device_id: u8, + pub first_valuator: u8, + pub valuators: &'input [i32], +} +impl<'input> SetDeviceValuatorsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let first_valuator_bytes = self.first_valuator.serialize(); + let num_valuators = u8::try_from(self.valuators.len()).expect("`valuators` has too many elements"); + let num_valuators_bytes = num_valuators.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_DEVICE_VALUATORS_REQUEST, + 0, + 0, + device_id_bytes[0], + first_valuator_bytes[0], + num_valuators_bytes[0], + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let valuators_bytes = self.valuators.serialize(); + let length_so_far = length_so_far + valuators_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), valuators_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_device_valuators<'c, 'input, Conn>(conn: &'c Conn, device_id: u8, first_valuator: u8, valuators: &'input [i32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let first_valuator_bytes = first_valuator.serialize(); - let num_valuators = u8::try_from(valuators.len()).expect("`valuators` has too many elements"); - let num_valuators_bytes = num_valuators.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_DEVICE_VALUATORS_REQUEST, - 0, - 0, - device_id_bytes[0], - first_valuator_bytes[0], - num_valuators_bytes[0], - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let valuators_bytes = valuators.serialize(); - let length_so_far = length_so_far + valuators_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&valuators_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetDeviceValuatorsRequest { + device_id, + first_valuator, + valuators, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -6313,33 +7005,53 @@ impl Serialize for DeviceState { self.data.serialize_into(bytes, control_id); } } - -/// Opcode for the GetDeviceControl request -pub const GET_DEVICE_CONTROL_REQUEST: u8 = 34; + +/// Opcode for the GetDeviceControl request +pub const GET_DEVICE_CONTROL_REQUEST: u8 = 34; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceControlRequest { + pub control_id: DeviceControl, + pub device_id: u8, +} +impl GetDeviceControlRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let control_id_bytes = u16::from(self.control_id).serialize(); + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_CONTROL_REQUEST, + 0, + 0, + control_id_bytes[0], + control_id_bytes[1], + device_id_bytes[0], + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_control(conn: &Conn, control_id: DeviceControl, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let control_id_bytes = u16::from(control_id).serialize(); - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_CONTROL_REQUEST, - 0, - 0, - control_id_bytes[0], - control_id_bytes[1], - device_id_bytes[0], - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceControlRequest { + control_id, + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -7122,34 +7834,56 @@ impl Serialize for DeviceCtl { /// Opcode for the ChangeDeviceControl request pub const CHANGE_DEVICE_CONTROL_REQUEST: u8 = 35; +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeDeviceControlRequest { + pub control_id: DeviceControl, + pub device_id: u8, + pub control: DeviceCtl, +} +impl ChangeDeviceControlRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let control_id_bytes = u16::from(self.control_id).serialize(); + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_DEVICE_CONTROL_REQUEST, + 0, + 0, + control_id_bytes[0], + control_id_bytes[1], + device_id_bytes[0], + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let control_bytes = self.control.serialize(); + let length_so_far = length_so_far + control_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), control_bytes.into(), padding0.into()], vec![])) + } +} pub fn change_device_control(conn: &Conn, control_id: DeviceControl, device_id: u8, control: DeviceCtl) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let control_id_bytes = u16::from(control_id).serialize(); - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_DEVICE_CONTROL_REQUEST, - 0, - 0, - control_id_bytes[0], - control_id_bytes[1], - device_id_bytes[0], - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let control_bytes = control.serialize(); - let length_so_far = length_so_far + control_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&control_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeDeviceControlRequest { + control_id, + device_id, + control, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -7181,29 +7915,47 @@ impl TryFrom<&[u8]> for ChangeDeviceControlReply { /// Opcode for the ListDeviceProperties request pub const LIST_DEVICE_PROPERTIES_REQUEST: u8 = 36; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListDevicePropertiesRequest { + pub device_id: u8, +} +impl ListDevicePropertiesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + LIST_DEVICE_PROPERTIES_REQUEST, + 0, + 0, + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_device_properties(conn: &Conn, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - LIST_DEVICE_PROPERTIES_REQUEST, - 0, - 0, - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListDevicePropertiesRequest { + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -7314,8 +8066,6 @@ impl TryFrom for PropertyFormat { } } -/// Opcode for the ChangeDeviceProperty request -pub const CHANGE_DEVICE_PROPERTY_REQUEST: u8 = 37; #[derive(Debug, Clone, PartialEq, Eq)] pub enum ChangeDevicePropertyAux { Data8(Vec), @@ -7378,131 +8128,209 @@ impl ChangeDevicePropertyAux { } } -pub fn change_device_property<'c, Conn>(conn: &'c Conn, property: xproto::Atom, type_: xproto::Atom, device_id: u8, mode: xproto::PropMode, num_items: u32, items: &ChangeDevicePropertyAux) -> Result, ConnectionError> +/// Opcode for the ChangeDeviceProperty request +pub const CHANGE_DEVICE_PROPERTY_REQUEST: u8 = 37; +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeDevicePropertyRequest<'input> { + pub property: xproto::Atom, + pub type_: xproto::Atom, + pub device_id: u8, + pub mode: xproto::PropMode, + pub num_items: u32, + pub items: &'input ChangeDevicePropertyAux, +} +impl<'input> ChangeDevicePropertyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let property_bytes = self.property.serialize(); + let type_bytes = self.type_.serialize(); + let device_id_bytes = self.device_id.serialize(); + let format = u8::try_from(self.items.switch_expr()).unwrap(); + let format_bytes = format.serialize(); + let mode_bytes = u8::from(self.mode).serialize(); + let num_items_bytes = self.num_items.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CHANGE_DEVICE_PROPERTY_REQUEST, + 0, + 0, + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + device_id_bytes[0], + format_bytes[0], + mode_bytes[0], + 0, + num_items_bytes[0], + num_items_bytes[1], + num_items_bytes[2], + num_items_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let items_bytes = self.items.serialize(format, self.num_items); + let length_so_far = length_so_far + items_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), items_bytes.into(), padding0.into()], vec![])) + } +} +pub fn change_device_property<'c, 'input, Conn>(conn: &'c Conn, property: xproto::Atom, type_: xproto::Atom, device_id: u8, mode: xproto::PropMode, num_items: u32, items: &'input ChangeDevicePropertyAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let property_bytes = property.serialize(); - let type_bytes = type_.serialize(); - let device_id_bytes = device_id.serialize(); - let format = u8::try_from(items.switch_expr()).unwrap(); - let format_bytes = format.serialize(); - let mode_bytes = u8::from(mode).serialize(); - let num_items_bytes = num_items.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CHANGE_DEVICE_PROPERTY_REQUEST, - 0, - 0, - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - device_id_bytes[0], - format_bytes[0], - mode_bytes[0], - 0, - num_items_bytes[0], - num_items_bytes[1], - num_items_bytes[2], - num_items_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let items_bytes = items.serialize(format, num_items); - let length_so_far = length_so_far + items_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&items_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeDevicePropertyRequest { + property, + type_, + device_id, + mode, + num_items, + items, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeleteDeviceProperty request pub const DELETE_DEVICE_PROPERTY_REQUEST: u8 = 38; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DeleteDevicePropertyRequest { + pub property: xproto::Atom, + pub device_id: u8, +} +impl DeleteDevicePropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let property_bytes = self.property.serialize(); + let device_id_bytes = self.device_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DELETE_DEVICE_PROPERTY_REQUEST, + 0, + 0, + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + device_id_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn delete_device_property(conn: &Conn, property: xproto::Atom, device_id: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let property_bytes = property.serialize(); - let device_id_bytes = device_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DELETE_DEVICE_PROPERTY_REQUEST, - 0, - 0, - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - device_id_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DeleteDevicePropertyRequest { + property, + device_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetDeviceProperty request pub const GET_DEVICE_PROPERTY_REQUEST: u8 = 39; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDevicePropertyRequest { + pub property: xproto::Atom, + pub type_: xproto::Atom, + pub offset: u32, + pub len: u32, + pub device_id: u8, + pub delete: bool, +} +impl GetDevicePropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let property_bytes = self.property.serialize(); + let type_bytes = self.type_.serialize(); + let offset_bytes = self.offset.serialize(); + let len_bytes = self.len.serialize(); + let device_id_bytes = self.device_id.serialize(); + let delete_bytes = self.delete.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_PROPERTY_REQUEST, + 0, + 0, + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + offset_bytes[0], + offset_bytes[1], + offset_bytes[2], + offset_bytes[3], + len_bytes[0], + len_bytes[1], + len_bytes[2], + len_bytes[3], + device_id_bytes[0], + delete_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_property(conn: &Conn, property: xproto::Atom, type_: xproto::Atom, offset: u32, len: u32, device_id: u8, delete: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let property_bytes = property.serialize(); - let type_bytes = type_.serialize(); - let offset_bytes = offset.serialize(); - let len_bytes = len.serialize(); - let device_id_bytes = device_id.serialize(); - let delete_bytes = delete.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_PROPERTY_REQUEST, - 0, - 0, - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - offset_bytes[0], - offset_bytes[1], - offset_bytes[2], - offset_bytes[3], - len_bytes[0], - len_bytes[1], - len_bytes[2], - len_bytes[3], - device_id_bytes[0], - delete_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDevicePropertyRequest { + property, + type_, + offset, + len, + device_id, + delete, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -7787,36 +8615,56 @@ impl Serialize for ModifierInfo { /// Opcode for the XIQueryPointer request pub const XI_QUERY_POINTER_REQUEST: u8 = 40; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIQueryPointerRequest { + pub window: xproto::Window, + pub deviceid: DeviceId, +} +impl XIQueryPointerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_QUERY_POINTER_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + deviceid_bytes[0], + deviceid_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_query_pointer(conn: &Conn, window: xproto::Window, deviceid: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let window_bytes = window.serialize(); - let deviceid_bytes = deviceid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_QUERY_POINTER_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - deviceid_bytes[0], - deviceid_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIQueryPointerRequest { + window, + deviceid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -7881,106 +8729,162 @@ impl XIQueryPointerReply { /// Opcode for the XIWarpPointer request pub const XI_WARP_POINTER_REQUEST: u8 = 41; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIWarpPointerRequest { + pub src_win: xproto::Window, + pub dst_win: xproto::Window, + pub src_x: Fp1616, + pub src_y: Fp1616, + pub src_width: u16, + pub src_height: u16, + pub dst_x: Fp1616, + pub dst_y: Fp1616, + pub deviceid: DeviceId, +} +impl XIWarpPointerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let src_win_bytes = self.src_win.serialize(); + let dst_win_bytes = self.dst_win.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let src_width_bytes = self.src_width.serialize(); + let src_height_bytes = self.src_height.serialize(); + let dst_x_bytes = self.dst_x.serialize(); + let dst_y_bytes = self.dst_y.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_WARP_POINTER_REQUEST, + 0, + 0, + src_win_bytes[0], + src_win_bytes[1], + src_win_bytes[2], + src_win_bytes[3], + dst_win_bytes[0], + dst_win_bytes[1], + dst_win_bytes[2], + dst_win_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_x_bytes[2], + src_x_bytes[3], + src_y_bytes[0], + src_y_bytes[1], + src_y_bytes[2], + src_y_bytes[3], + src_width_bytes[0], + src_width_bytes[1], + src_height_bytes[0], + src_height_bytes[1], + dst_x_bytes[0], + dst_x_bytes[1], + dst_x_bytes[2], + dst_x_bytes[3], + dst_y_bytes[0], + dst_y_bytes[1], + dst_y_bytes[2], + dst_y_bytes[3], + deviceid_bytes[0], + deviceid_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_warp_pointer(conn: &Conn, src_win: xproto::Window, dst_win: xproto::Window, src_x: Fp1616, src_y: Fp1616, src_width: u16, src_height: u16, dst_x: Fp1616, dst_y: Fp1616, deviceid: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let src_win_bytes = src_win.serialize(); - let dst_win_bytes = dst_win.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let src_width_bytes = src_width.serialize(); - let src_height_bytes = src_height.serialize(); - let dst_x_bytes = dst_x.serialize(); - let dst_y_bytes = dst_y.serialize(); - let deviceid_bytes = deviceid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_WARP_POINTER_REQUEST, - 0, - 0, - src_win_bytes[0], - src_win_bytes[1], - src_win_bytes[2], - src_win_bytes[3], - dst_win_bytes[0], - dst_win_bytes[1], - dst_win_bytes[2], - dst_win_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_x_bytes[2], - src_x_bytes[3], - src_y_bytes[0], - src_y_bytes[1], - src_y_bytes[2], - src_y_bytes[3], - src_width_bytes[0], - src_width_bytes[1], - src_height_bytes[0], - src_height_bytes[1], - dst_x_bytes[0], - dst_x_bytes[1], - dst_x_bytes[2], - dst_x_bytes[3], - dst_y_bytes[0], - dst_y_bytes[1], - dst_y_bytes[2], - dst_y_bytes[3], - deviceid_bytes[0], - deviceid_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIWarpPointerRequest { + src_win, + dst_win, + src_x, + src_y, + src_width, + src_height, + dst_x, + dst_y, + deviceid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the XIChangeCursor request pub const XI_CHANGE_CURSOR_REQUEST: u8 = 42; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIChangeCursorRequest { + pub window: xproto::Window, + pub cursor: xproto::Cursor, + pub deviceid: DeviceId, +} +impl XIChangeCursorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let cursor_bytes = self.cursor.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_CHANGE_CURSOR_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + deviceid_bytes[0], + deviceid_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_change_cursor(conn: &Conn, window: xproto::Window, cursor: xproto::Cursor, deviceid: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let window_bytes = window.serialize(); - let cursor_bytes = cursor.serialize(); - let deviceid_bytes = deviceid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_CHANGE_CURSOR_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - deviceid_bytes[0], - deviceid_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIChangeCursorRequest { + window, + cursor, + deviceid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -8664,95 +9568,151 @@ impl Serialize for HierarchyChange { /// Opcode for the XIChangeHierarchy request pub const XI_CHANGE_HIERARCHY_REQUEST: u8 = 43; -pub fn xi_change_hierarchy<'c, Conn>(conn: &'c Conn, changes: &[HierarchyChange]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct XIChangeHierarchyRequest<'input> { + pub changes: &'input [HierarchyChange], +} +impl<'input> XIChangeHierarchyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let num_changes = u8::try_from(self.changes.len()).expect("`changes` has too many elements"); + let num_changes_bytes = num_changes.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_CHANGE_HIERARCHY_REQUEST, + 0, + 0, + num_changes_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let changes_bytes = self.changes.serialize(); + let length_so_far = length_so_far + changes_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), changes_bytes.into(), padding0.into()], vec![])) + } +} +pub fn xi_change_hierarchy<'c, 'input, Conn>(conn: &'c Conn, changes: &'input [HierarchyChange]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let num_changes = u8::try_from(changes.len()).expect("`changes` has too many elements"); - let num_changes_bytes = num_changes.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_CHANGE_HIERARCHY_REQUEST, - 0, - 0, - num_changes_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let changes_bytes = changes.serialize(); - let length_so_far = length_so_far + changes_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&changes_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = XIChangeHierarchyRequest { + changes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the XISetClientPointer request pub const XI_SET_CLIENT_POINTER_REQUEST: u8 = 44; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XISetClientPointerRequest { + pub window: xproto::Window, + pub deviceid: DeviceId, +} +impl XISetClientPointerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_SET_CLIENT_POINTER_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + deviceid_bytes[0], + deviceid_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_set_client_pointer(conn: &Conn, window: xproto::Window, deviceid: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let window_bytes = window.serialize(); - let deviceid_bytes = deviceid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_SET_CLIENT_POINTER_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - deviceid_bytes[0], - deviceid_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XISetClientPointerRequest { + window, + deviceid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the XIGetClientPointer request pub const XI_GET_CLIENT_POINTER_REQUEST: u8 = 45; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIGetClientPointerRequest { + pub window: xproto::Window, +} +impl XIGetClientPointerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_GET_CLIENT_POINTER_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_get_client_pointer(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_GET_CLIENT_POINTER_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIGetClientPointerRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -8940,67 +9900,107 @@ impl EventMask { /// Opcode for the XISelectEvents request pub const XI_SELECT_EVENTS_REQUEST: u8 = 46; -pub fn xi_select_events<'c, Conn>(conn: &'c Conn, window: xproto::Window, masks: &[EventMask]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct XISelectEventsRequest<'input> { + pub window: xproto::Window, + pub masks: &'input [EventMask], +} +impl<'input> XISelectEventsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let num_mask = u16::try_from(self.masks.len()).expect("`masks` has too many elements"); + let num_mask_bytes = num_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_SELECT_EVENTS_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + num_mask_bytes[0], + num_mask_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let masks_bytes = self.masks.serialize(); + let length_so_far = length_so_far + masks_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), masks_bytes.into(), padding0.into()], vec![])) + } +} +pub fn xi_select_events<'c, 'input, Conn>(conn: &'c Conn, window: xproto::Window, masks: &'input [EventMask]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let num_mask = u16::try_from(masks.len()).expect("`masks` has too many elements"); - let num_mask_bytes = num_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_SELECT_EVENTS_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - num_mask_bytes[0], - num_mask_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let masks_bytes = masks.serialize(); - let length_so_far = length_so_far + masks_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&masks_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = XISelectEventsRequest { + window, + masks, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the XIQueryVersion request pub const XI_QUERY_VERSION_REQUEST: u8 = 47; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIQueryVersionRequest { + pub major_version: u16, + pub minor_version: u16, +} +impl XIQueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_QUERY_VERSION_REQUEST, + 0, + 0, + major_version_bytes[0], + major_version_bytes[1], + minor_version_bytes[0], + minor_version_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_query_version(conn: &Conn, major_version: u16, minor_version: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_QUERY_VERSION_REQUEST, - 0, - 0, - major_version_bytes[0], - major_version_bytes[1], - minor_version_bytes[0], - minor_version_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIQueryVersionRequest { + major_version, + minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -10260,31 +11260,49 @@ impl XIDeviceInfo { /// Opcode for the XIQueryDevice request pub const XI_QUERY_DEVICE_REQUEST: u8 = 48; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIQueryDeviceRequest { + pub deviceid: DeviceId, +} +impl XIQueryDeviceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let deviceid_bytes = self.deviceid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_QUERY_DEVICE_REQUEST, + 0, + 0, + deviceid_bytes[0], + deviceid_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_query_device(conn: &Conn, deviceid: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let deviceid_bytes = deviceid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_QUERY_DEVICE_REQUEST, - 0, - 0, - deviceid_bytes[0], - deviceid_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIQueryDeviceRequest { + deviceid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -10328,75 +11346,115 @@ impl XIQueryDeviceReply { .try_into().unwrap() } } - -/// Opcode for the XISetFocus request -pub const XI_SET_FOCUS_REQUEST: u8 = 49; + +/// Opcode for the XISetFocus request +pub const XI_SET_FOCUS_REQUEST: u8 = 49; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XISetFocusRequest { + pub window: xproto::Window, + pub time: xproto::Timestamp, + pub deviceid: DeviceId, +} +impl XISetFocusRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let time_bytes = self.time.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_SET_FOCUS_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + deviceid_bytes[0], + deviceid_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_set_focus(conn: &Conn, window: xproto::Window, time: A, deviceid: B) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let time: xproto::Timestamp = time.into(); let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let window_bytes = window.serialize(); - let time_bytes = time.serialize(); - let deviceid_bytes = deviceid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_SET_FOCUS_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - deviceid_bytes[0], - deviceid_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XISetFocusRequest { + window, + time, + deviceid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the XIGetFocus request pub const XI_GET_FOCUS_REQUEST: u8 = 50; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIGetFocusRequest { + pub deviceid: DeviceId, +} +impl XIGetFocusRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let deviceid_bytes = self.deviceid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_GET_FOCUS_REQUEST, + 0, + 0, + deviceid_bytes[0], + deviceid_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_get_focus(conn: &Conn, deviceid: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let deviceid_bytes = deviceid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_GET_FOCUS_REQUEST, - 0, - 0, - deviceid_bytes[0], - deviceid_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIGetFocusRequest { + deviceid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -10497,61 +11555,93 @@ impl TryFrom for GrabOwner { /// Opcode for the XIGrabDevice request pub const XI_GRAB_DEVICE_REQUEST: u8 = 51; -pub fn xi_grab_device<'c, Conn, A, B>(conn: &'c Conn, window: xproto::Window, time: A, cursor: xproto::Cursor, deviceid: B, mode: xproto::GrabMode, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct XIGrabDeviceRequest<'input> { + pub window: xproto::Window, + pub time: xproto::Timestamp, + pub cursor: xproto::Cursor, + pub deviceid: DeviceId, + pub mode: xproto::GrabMode, + pub paired_device_mode: xproto::GrabMode, + pub owner_events: GrabOwner, + pub mask: &'input [u32], +} +impl<'input> XIGrabDeviceRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let time_bytes = self.time.serialize(); + let cursor_bytes = self.cursor.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let mode_bytes = u8::from(self.mode).serialize(); + let paired_device_mode_bytes = u8::from(self.paired_device_mode).serialize(); + let owner_events_bytes = bool::from(self.owner_events).serialize(); + let mask_len = u16::try_from(self.mask.len()).expect("`mask` has too many elements"); + let mask_len_bytes = mask_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_GRAB_DEVICE_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + deviceid_bytes[0], + deviceid_bytes[1], + mode_bytes[0], + paired_device_mode_bytes[0], + owner_events_bytes[0], + 0, + mask_len_bytes[0], + mask_len_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let mask_bytes = self.mask.serialize(); + let length_so_far = length_so_far + mask_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), mask_bytes.into(), padding0.into()], vec![])) + } +} +pub fn xi_grab_device<'c, 'input, Conn, A, B>(conn: &'c Conn, window: xproto::Window, time: A, cursor: xproto::Cursor, deviceid: B, mode: xproto::GrabMode, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let time: xproto::Timestamp = time.into(); let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let window_bytes = window.serialize(); - let time_bytes = time.serialize(); - let cursor_bytes = cursor.serialize(); - let deviceid_bytes = deviceid.serialize(); - let mode_bytes = u8::from(mode).serialize(); - let paired_device_mode_bytes = u8::from(paired_device_mode).serialize(); - let owner_events_bytes = bool::from(owner_events).serialize(); - let mask_len = u16::try_from(mask.len()).expect("`mask` has too many elements"); - let mask_len_bytes = mask_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_GRAB_DEVICE_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - deviceid_bytes[0], - deviceid_bytes[1], - mode_bytes[0], - paired_device_mode_bytes[0], - owner_events_bytes[0], - 0, - mask_len_bytes[0], - mask_len_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let mask_bytes = mask.serialize(); - let length_so_far = length_so_far + mask_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&mask_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = XIGrabDeviceRequest { + window, + time, + cursor, + deviceid, + mode, + paired_device_mode, + owner_events, + mask, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -10583,38 +11673,58 @@ impl TryFrom<&[u8]> for XIGrabDeviceReply { /// Opcode for the XIUngrabDevice request pub const XI_UNGRAB_DEVICE_REQUEST: u8 = 52; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIUngrabDeviceRequest { + pub time: xproto::Timestamp, + pub deviceid: DeviceId, +} +impl XIUngrabDeviceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let time_bytes = self.time.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_UNGRAB_DEVICE_REQUEST, + 0, + 0, + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + deviceid_bytes[0], + deviceid_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_ungrab_device(conn: &Conn, time: A, deviceid: B) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let time: xproto::Timestamp = time.into(); let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let time_bytes = time.serialize(); - let deviceid_bytes = deviceid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_UNGRAB_DEVICE_REQUEST, - 0, - 0, - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - deviceid_bytes[0], - deviceid_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIUngrabDeviceRequest { + time, + deviceid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -10699,49 +11809,75 @@ impl TryFrom for EventMode { /// Opcode for the XIAllowEvents request pub const XI_ALLOW_EVENTS_REQUEST: u8 = 53; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIAllowEventsRequest { + pub time: xproto::Timestamp, + pub deviceid: DeviceId, + pub event_mode: EventMode, + pub touchid: u32, + pub grab_window: xproto::Window, +} +impl XIAllowEventsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let time_bytes = self.time.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let event_mode_bytes = u8::from(self.event_mode).serialize(); + let touchid_bytes = self.touchid.serialize(); + let grab_window_bytes = self.grab_window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_ALLOW_EVENTS_REQUEST, + 0, + 0, + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + deviceid_bytes[0], + deviceid_bytes[1], + event_mode_bytes[0], + 0, + touchid_bytes[0], + touchid_bytes[1], + touchid_bytes[2], + touchid_bytes[3], + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_allow_events(conn: &Conn, time: A, deviceid: B, event_mode: EventMode, touchid: u32, grab_window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let time: xproto::Timestamp = time.into(); let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let time_bytes = time.serialize(); - let deviceid_bytes = deviceid.serialize(); - let event_mode_bytes = u8::from(event_mode).serialize(); - let touchid_bytes = touchid.serialize(); - let grab_window_bytes = grab_window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_ALLOW_EVENTS_REQUEST, - 0, - 0, - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - deviceid_bytes[0], - deviceid_bytes[1], - event_mode_bytes[0], - 0, - touchid_bytes[0], - touchid_bytes[1], - touchid_bytes[2], - touchid_bytes[3], - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIAllowEventsRequest { + time, + deviceid, + event_mode, + touchid, + grab_window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -10955,75 +12091,113 @@ impl Serialize for GrabModifierInfo { /// Opcode for the XIPassiveGrabDevice request pub const XI_PASSIVE_GRAB_DEVICE_REQUEST: u8 = 54; -pub fn xi_passive_grab_device<'c, Conn, A, B>(conn: &'c Conn, time: A, grab_window: xproto::Window, cursor: xproto::Cursor, detail: u32, deviceid: B, grab_type: GrabType, grab_mode: GrabMode22, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &[u32], modifiers: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct XIPassiveGrabDeviceRequest<'input> { + pub time: xproto::Timestamp, + pub grab_window: xproto::Window, + pub cursor: xproto::Cursor, + pub detail: u32, + pub deviceid: DeviceId, + pub grab_type: GrabType, + pub grab_mode: GrabMode22, + pub paired_device_mode: xproto::GrabMode, + pub owner_events: GrabOwner, + pub mask: &'input [u32], + pub modifiers: &'input [u32], +} +impl<'input> XIPassiveGrabDeviceRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let time_bytes = self.time.serialize(); + let grab_window_bytes = self.grab_window.serialize(); + let cursor_bytes = self.cursor.serialize(); + let detail_bytes = self.detail.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let num_modifiers = u16::try_from(self.modifiers.len()).expect("`modifiers` has too many elements"); + let num_modifiers_bytes = num_modifiers.serialize(); + let mask_len = u16::try_from(self.mask.len()).expect("`mask` has too many elements"); + let mask_len_bytes = mask_len.serialize(); + let grab_type_bytes = u8::from(self.grab_type).serialize(); + let grab_mode_bytes = u8::from(self.grab_mode).serialize(); + let paired_device_mode_bytes = u8::from(self.paired_device_mode).serialize(); + let owner_events_bytes = bool::from(self.owner_events).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_PASSIVE_GRAB_DEVICE_REQUEST, + 0, + 0, + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + detail_bytes[0], + detail_bytes[1], + detail_bytes[2], + detail_bytes[3], + deviceid_bytes[0], + deviceid_bytes[1], + num_modifiers_bytes[0], + num_modifiers_bytes[1], + mask_len_bytes[0], + mask_len_bytes[1], + grab_type_bytes[0], + grab_mode_bytes[0], + paired_device_mode_bytes[0], + owner_events_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let mask_bytes = self.mask.serialize(); + let length_so_far = length_so_far + mask_bytes.len(); + let modifiers_bytes = self.modifiers.serialize(); + let length_so_far = length_so_far + modifiers_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), mask_bytes.into(), modifiers_bytes.into(), padding0.into()], vec![])) + } +} +pub fn xi_passive_grab_device<'c, 'input, Conn, A, B>(conn: &'c Conn, time: A, grab_window: xproto::Window, cursor: xproto::Cursor, detail: u32, deviceid: B, grab_type: GrabType, grab_mode: GrabMode22, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &'input [u32], modifiers: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let time: xproto::Timestamp = time.into(); let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let time_bytes = time.serialize(); - let grab_window_bytes = grab_window.serialize(); - let cursor_bytes = cursor.serialize(); - let detail_bytes = detail.serialize(); - let deviceid_bytes = deviceid.serialize(); - let num_modifiers = u16::try_from(modifiers.len()).expect("`modifiers` has too many elements"); - let num_modifiers_bytes = num_modifiers.serialize(); - let mask_len = u16::try_from(mask.len()).expect("`mask` has too many elements"); - let mask_len_bytes = mask_len.serialize(); - let grab_type_bytes = u8::from(grab_type).serialize(); - let grab_mode_bytes = u8::from(grab_mode).serialize(); - let paired_device_mode_bytes = u8::from(paired_device_mode).serialize(); - let owner_events_bytes = bool::from(owner_events).serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_PASSIVE_GRAB_DEVICE_REQUEST, - 0, - 0, - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - detail_bytes[0], - detail_bytes[1], - detail_bytes[2], - detail_bytes[3], - deviceid_bytes[0], - deviceid_bytes[1], - num_modifiers_bytes[0], - num_modifiers_bytes[1], - mask_len_bytes[0], - mask_len_bytes[1], - grab_type_bytes[0], - grab_mode_bytes[0], - paired_device_mode_bytes[0], - owner_events_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let mask_bytes = mask.serialize(); - let length_so_far = length_so_far + mask_bytes.len(); - let modifiers_bytes = modifiers.serialize(); - let length_so_far = length_so_far + modifiers_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&mask_bytes), IoSlice::new(&modifiers_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = XIPassiveGrabDeviceRequest { + time, + grab_window, + cursor, + detail, + deviceid, + grab_type, + grab_mode, + paired_device_mode, + owner_events, + mask, + modifiers, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -11070,81 +12244,125 @@ impl XIPassiveGrabDeviceReply { /// Opcode for the XIPassiveUngrabDevice request pub const XI_PASSIVE_UNGRAB_DEVICE_REQUEST: u8 = 55; -pub fn xi_passive_ungrab_device<'c, Conn, A>(conn: &'c Conn, grab_window: xproto::Window, detail: u32, deviceid: A, grab_type: GrabType, modifiers: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct XIPassiveUngrabDeviceRequest<'input> { + pub grab_window: xproto::Window, + pub detail: u32, + pub deviceid: DeviceId, + pub grab_type: GrabType, + pub modifiers: &'input [u32], +} +impl<'input> XIPassiveUngrabDeviceRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let grab_window_bytes = self.grab_window.serialize(); + let detail_bytes = self.detail.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let num_modifiers = u16::try_from(self.modifiers.len()).expect("`modifiers` has too many elements"); + let num_modifiers_bytes = num_modifiers.serialize(); + let grab_type_bytes = u8::from(self.grab_type).serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_PASSIVE_UNGRAB_DEVICE_REQUEST, + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + detail_bytes[0], + detail_bytes[1], + detail_bytes[2], + detail_bytes[3], + deviceid_bytes[0], + deviceid_bytes[1], + num_modifiers_bytes[0], + num_modifiers_bytes[1], + grab_type_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let modifiers_bytes = self.modifiers.serialize(); + let length_so_far = length_so_far + modifiers_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), modifiers_bytes.into(), padding0.into()], vec![])) + } +} +pub fn xi_passive_ungrab_device<'c, 'input, Conn, A>(conn: &'c Conn, grab_window: xproto::Window, detail: u32, deviceid: A, grab_type: GrabType, modifiers: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let grab_window_bytes = grab_window.serialize(); - let detail_bytes = detail.serialize(); - let deviceid_bytes = deviceid.serialize(); - let num_modifiers = u16::try_from(modifiers.len()).expect("`modifiers` has too many elements"); - let num_modifiers_bytes = num_modifiers.serialize(); - let grab_type_bytes = u8::from(grab_type).serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_PASSIVE_UNGRAB_DEVICE_REQUEST, - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - detail_bytes[0], - detail_bytes[1], - detail_bytes[2], - detail_bytes[3], - deviceid_bytes[0], - deviceid_bytes[1], - num_modifiers_bytes[0], - num_modifiers_bytes[1], - grab_type_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let modifiers_bytes = modifiers.serialize(); - let length_so_far = length_so_far + modifiers_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&modifiers_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = XIPassiveUngrabDeviceRequest { + grab_window, + detail, + deviceid, + grab_type, + modifiers, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the XIListProperties request pub const XI_LIST_PROPERTIES_REQUEST: u8 = 56; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIListPropertiesRequest { + pub deviceid: DeviceId, +} +impl XIListPropertiesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let deviceid_bytes = self.deviceid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_LIST_PROPERTIES_REQUEST, + 0, + 0, + deviceid_bytes[0], + deviceid_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_list_properties(conn: &Conn, deviceid: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let deviceid_bytes = deviceid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_LIST_PROPERTIES_REQUEST, - 0, - 0, - deviceid_bytes[0], - deviceid_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIListPropertiesRequest { + deviceid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -11189,8 +12407,6 @@ impl XIListPropertiesReply { } } -/// Opcode for the XIChangeProperty request -pub const XI_CHANGE_PROPERTY_REQUEST: u8 = 57; #[derive(Debug, Clone, PartialEq, Eq)] pub enum XIChangePropertyAux { Data8(Vec), @@ -11253,137 +12469,215 @@ impl XIChangePropertyAux { } } -pub fn xi_change_property<'c, Conn, A>(conn: &'c Conn, deviceid: A, mode: xproto::PropMode, property: xproto::Atom, type_: xproto::Atom, num_items: u32, items: &XIChangePropertyAux) -> Result, ConnectionError> +/// Opcode for the XIChangeProperty request +pub const XI_CHANGE_PROPERTY_REQUEST: u8 = 57; +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct XIChangePropertyRequest<'input> { + pub deviceid: DeviceId, + pub mode: xproto::PropMode, + pub property: xproto::Atom, + pub type_: xproto::Atom, + pub num_items: u32, + pub items: &'input XIChangePropertyAux, +} +impl<'input> XIChangePropertyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let deviceid_bytes = self.deviceid.serialize(); + let mode_bytes = u8::from(self.mode).serialize(); + let format = u8::try_from(self.items.switch_expr()).unwrap(); + let format_bytes = format.serialize(); + let property_bytes = self.property.serialize(); + let type_bytes = self.type_.serialize(); + let num_items_bytes = self.num_items.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_CHANGE_PROPERTY_REQUEST, + 0, + 0, + deviceid_bytes[0], + deviceid_bytes[1], + mode_bytes[0], + format_bytes[0], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + num_items_bytes[0], + num_items_bytes[1], + num_items_bytes[2], + num_items_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let items_bytes = self.items.serialize(format, self.num_items); + let length_so_far = length_so_far + items_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), items_bytes.into(), padding0.into()], vec![])) + } +} +pub fn xi_change_property<'c, 'input, Conn, A>(conn: &'c Conn, deviceid: A, mode: xproto::PropMode, property: xproto::Atom, type_: xproto::Atom, num_items: u32, items: &'input XIChangePropertyAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let deviceid_bytes = deviceid.serialize(); - let mode_bytes = u8::from(mode).serialize(); - let format = u8::try_from(items.switch_expr()).unwrap(); - let format_bytes = format.serialize(); - let property_bytes = property.serialize(); - let type_bytes = type_.serialize(); - let num_items_bytes = num_items.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_CHANGE_PROPERTY_REQUEST, - 0, - 0, - deviceid_bytes[0], - deviceid_bytes[1], - mode_bytes[0], - format_bytes[0], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - num_items_bytes[0], - num_items_bytes[1], - num_items_bytes[2], - num_items_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let items_bytes = items.serialize(format, num_items); - let length_so_far = length_so_far + items_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&items_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = XIChangePropertyRequest { + deviceid, + mode, + property, + type_, + num_items, + items, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the XIDeleteProperty request pub const XI_DELETE_PROPERTY_REQUEST: u8 = 58; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIDeletePropertyRequest { + pub deviceid: DeviceId, + pub property: xproto::Atom, +} +impl XIDeletePropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let deviceid_bytes = self.deviceid.serialize(); + let property_bytes = self.property.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_DELETE_PROPERTY_REQUEST, + 0, + 0, + deviceid_bytes[0], + deviceid_bytes[1], + 0, + 0, + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_delete_property(conn: &Conn, deviceid: A, property: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let deviceid_bytes = deviceid.serialize(); - let property_bytes = property.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_DELETE_PROPERTY_REQUEST, - 0, - 0, - deviceid_bytes[0], - deviceid_bytes[1], - 0, - 0, - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIDeletePropertyRequest { + deviceid, + property, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the XIGetProperty request pub const XI_GET_PROPERTY_REQUEST: u8 = 59; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIGetPropertyRequest { + pub deviceid: DeviceId, + pub delete: bool, + pub property: xproto::Atom, + pub type_: xproto::Atom, + pub offset: u32, + pub len: u32, +} +impl XIGetPropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let deviceid_bytes = self.deviceid.serialize(); + let delete_bytes = self.delete.serialize(); + let property_bytes = self.property.serialize(); + let type_bytes = self.type_.serialize(); + let offset_bytes = self.offset.serialize(); + let len_bytes = self.len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_GET_PROPERTY_REQUEST, + 0, + 0, + deviceid_bytes[0], + deviceid_bytes[1], + delete_bytes[0], + 0, + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + offset_bytes[0], + offset_bytes[1], + offset_bytes[2], + offset_bytes[3], + len_bytes[0], + len_bytes[1], + len_bytes[2], + len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_get_property(conn: &Conn, deviceid: A, delete: bool, property: xproto::Atom, type_: xproto::Atom, offset: u32, len: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let deviceid: DeviceId = deviceid.into(); - let length_so_far = 0; - let deviceid_bytes = deviceid.serialize(); - let delete_bytes = delete.serialize(); - let property_bytes = property.serialize(); - let type_bytes = type_.serialize(); - let offset_bytes = offset.serialize(); - let len_bytes = len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_GET_PROPERTY_REQUEST, - 0, - 0, - deviceid_bytes[0], - deviceid_bytes[1], - delete_bytes[0], - 0, - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - offset_bytes[0], - offset_bytes[1], - offset_bytes[2], - offset_bytes[3], - len_bytes[0], - len_bytes[1], - len_bytes[2], - len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIGetPropertyRequest { + deviceid, + delete, + property, + type_, + offset, + len, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -11491,29 +12785,47 @@ impl TryFrom<&[u8]> for XIGetPropertyReply { /// Opcode for the XIGetSelectedEvents request pub const XI_GET_SELECTED_EVENTS_REQUEST: u8 = 60; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct XIGetSelectedEventsRequest { + pub window: xproto::Window, +} +impl XIGetSelectedEventsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_GET_SELECTED_EVENTS_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn xi_get_selected_events(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_GET_SELECTED_EVENTS_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = XIGetSelectedEventsRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -11612,34 +12924,52 @@ impl Serialize for BarrierReleasePointerInfo { /// Opcode for the XIBarrierReleasePointer request pub const XI_BARRIER_RELEASE_POINTER_REQUEST: u8 = 61; -pub fn xi_barrier_release_pointer<'c, Conn>(conn: &'c Conn, barriers: &[BarrierReleasePointerInfo]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct XIBarrierReleasePointerRequest<'input> { + pub barriers: &'input [BarrierReleasePointerInfo], +} +impl<'input> XIBarrierReleasePointerRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let num_barriers = u32::try_from(self.barriers.len()).expect("`barriers` has too many elements"); + let num_barriers_bytes = num_barriers.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + XI_BARRIER_RELEASE_POINTER_REQUEST, + 0, + 0, + num_barriers_bytes[0], + num_barriers_bytes[1], + num_barriers_bytes[2], + num_barriers_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let barriers_bytes = self.barriers.serialize(); + let length_so_far = length_so_far + barriers_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), barriers_bytes.into(), padding0.into()], vec![])) + } +} +pub fn xi_barrier_release_pointer<'c, 'input, Conn>(conn: &'c Conn, barriers: &'input [BarrierReleasePointerInfo]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let num_barriers = u32::try_from(barriers.len()).expect("`barriers` has too many elements"); - let num_barriers_bytes = num_barriers.serialize(); - let mut request0 = [ - extension_information.major_opcode, - XI_BARRIER_RELEASE_POINTER_REQUEST, - 0, - 0, - num_barriers_bytes[0], - num_barriers_bytes[1], - num_barriers_bytes[2], - num_barriers_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let barriers_bytes = barriers.serialize(); - let length_so_far = length_so_far + barriers_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&barriers_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = XIBarrierReleasePointerRequest { + barriers, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeviceValuator event @@ -14499,49 +15829,75 @@ impl From<&DevicePropertyNotifyEvent> for EventForSend { /// Opcode for the SendExtensionEvent request pub const SEND_EXTENSION_EVENT_REQUEST: u8 = 31; -pub fn send_extension_event<'c, Conn>(conn: &'c Conn, destination: xproto::Window, device_id: u8, propagate: bool, events: &[EventForSend], classes: &[EventClass]) -> Result, ConnectionError> +#[derive(Debug, Clone)] +pub struct SendExtensionEventRequest<'input> { + pub destination: xproto::Window, + pub device_id: u8, + pub propagate: bool, + pub events: &'input [EventForSend], + pub classes: &'input [EventClass], +} +impl<'input> SendExtensionEventRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let destination_bytes = self.destination.serialize(); + let device_id_bytes = self.device_id.serialize(); + let propagate_bytes = self.propagate.serialize(); + let num_classes = u16::try_from(self.classes.len()).expect("`classes` has too many elements"); + let num_classes_bytes = num_classes.serialize(); + let num_events = u8::try_from(self.events.len()).expect("`events` has too many elements"); + let num_events_bytes = num_events.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SEND_EXTENSION_EVENT_REQUEST, + 0, + 0, + destination_bytes[0], + destination_bytes[1], + destination_bytes[2], + destination_bytes[3], + device_id_bytes[0], + propagate_bytes[0], + num_classes_bytes[0], + num_classes_bytes[1], + num_events_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let events_bytes = self.events.serialize(); + let length_so_far = length_so_far + events_bytes.len(); + let classes_bytes = self.classes.serialize(); + let length_so_far = length_so_far + classes_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), events_bytes.into(), classes_bytes.into(), padding0.into()], vec![])) + } +} +pub fn send_extension_event<'c, 'input, Conn>(conn: &'c Conn, destination: xproto::Window, device_id: u8, propagate: bool, events: &'input [EventForSend], classes: &'input [EventClass]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let destination_bytes = destination.serialize(); - let device_id_bytes = device_id.serialize(); - let propagate_bytes = propagate.serialize(); - let num_classes = u16::try_from(classes.len()).expect("`classes` has too many elements"); - let num_classes_bytes = num_classes.serialize(); - let num_events = u8::try_from(events.len()).expect("`events` has too many elements"); - let num_events_bytes = num_events.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SEND_EXTENSION_EVENT_REQUEST, - 0, - 0, - destination_bytes[0], - destination_bytes[1], - destination_bytes[2], - destination_bytes[3], - device_id_bytes[0], - propagate_bytes[0], - num_classes_bytes[0], - num_classes_bytes[1], - num_events_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let events_bytes = events.serialize(); - let length_so_far = length_so_far + events_bytes.len(); - let classes_bytes = classes.serialize(); - let length_so_far = length_so_far + classes_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&events_bytes), IoSlice::new(&classes_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SendExtensionEventRequest { + destination, + device_id, + propagate, + events, + classes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Device error @@ -14901,7 +16257,7 @@ impl From for [u8; 32] { /// Extension trait defining the requests of this extension. pub trait ConnectionExt: RequestConnection { - fn xinput_get_extension_version<'c>(&'c self, name: &[u8]) -> Result, ConnectionError> + fn xinput_get_extension_version<'c, 'input>(&'c self, name: &'input [u8]) -> Result, ConnectionError> { get_extension_version(self, name) } @@ -14921,7 +16277,7 @@ pub trait ConnectionExt: RequestConnection { { set_device_mode(self, device_id, mode) } - fn xinput_select_extension_event<'c>(&'c self, window: xproto::Window, classes: &[EventClass]) -> Result, ConnectionError> + fn xinput_select_extension_event<'c, 'input>(&'c self, window: xproto::Window, classes: &'input [EventClass]) -> Result, ConnectionError> { select_extension_event(self, window, classes) } @@ -14929,7 +16285,7 @@ pub trait ConnectionExt: RequestConnection { { get_selected_extension_events(self, window) } - fn xinput_change_device_dont_propagate_list<'c>(&'c self, window: xproto::Window, mode: PropagateMode, classes: &[EventClass]) -> Result, ConnectionError> + fn xinput_change_device_dont_propagate_list<'c, 'input>(&'c self, window: xproto::Window, mode: PropagateMode, classes: &'input [EventClass]) -> Result, ConnectionError> { change_device_dont_propagate_list(self, window, mode, classes) } @@ -14951,7 +16307,7 @@ pub trait ConnectionExt: RequestConnection { { change_pointer_device(self, x_axis, y_axis, device_id) } - fn xinput_grab_device<'c, A>(&'c self, grab_window: xproto::Window, time: A, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, device_id: u8, classes: &[EventClass]) -> Result, ConnectionError> + fn xinput_grab_device<'c, 'input, A>(&'c self, grab_window: xproto::Window, time: A, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, device_id: u8, classes: &'input [EventClass]) -> Result, ConnectionError> where A: Into, { @@ -14963,7 +16319,7 @@ pub trait ConnectionExt: RequestConnection { { ungrab_device(self, time, device_id) } - fn xinput_grab_device_key<'c, A, B, C>(&'c self, grab_window: xproto::Window, modifiers: A, modifier_device: B, grabbed_device: u8, key: C, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, classes: &[EventClass]) -> Result, ConnectionError> + fn xinput_grab_device_key<'c, 'input, A, B, C>(&'c self, grab_window: xproto::Window, modifiers: A, modifier_device: B, grabbed_device: u8, key: C, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, classes: &'input [EventClass]) -> Result, ConnectionError> where A: Into, B: Into, @@ -14979,7 +16335,7 @@ pub trait ConnectionExt: RequestConnection { { ungrab_device_key(self, grab_window, modifiers, modifier_device, key, grabbed_device) } - fn xinput_grab_device_button<'c, A, B, C>(&'c self, grab_window: xproto::Window, grabbed_device: u8, modifier_device: A, modifiers: B, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, button: C, owner_events: bool, classes: &[EventClass]) -> Result, ConnectionError> + fn xinput_grab_device_button<'c, 'input, A, B, C>(&'c self, grab_window: xproto::Window, grabbed_device: u8, modifier_device: A, modifiers: B, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, button: C, owner_events: bool, classes: &'input [EventClass]) -> Result, ConnectionError> where A: Into, B: Into, @@ -15026,7 +16382,7 @@ pub trait ConnectionExt: RequestConnection { { get_device_key_mapping(self, device_id, first_keycode, count) } - fn xinput_change_device_key_mapping<'c>(&'c self, device_id: u8, first_keycode: KeyCode, keysyms_per_keycode: u8, keycode_count: u8, keysyms: &[xproto::Keysym]) -> Result, ConnectionError> + fn xinput_change_device_key_mapping<'c, 'input>(&'c self, device_id: u8, first_keycode: KeyCode, keysyms_per_keycode: u8, keycode_count: u8, keysyms: &'input [xproto::Keysym]) -> Result, ConnectionError> { change_device_key_mapping(self, device_id, first_keycode, keysyms_per_keycode, keycode_count, keysyms) } @@ -15034,7 +16390,7 @@ pub trait ConnectionExt: RequestConnection { { get_device_modifier_mapping(self, device_id) } - fn xinput_set_device_modifier_mapping<'c>(&'c self, device_id: u8, keymaps: &[u8]) -> Result, ConnectionError> + fn xinput_set_device_modifier_mapping<'c, 'input>(&'c self, device_id: u8, keymaps: &'input [u8]) -> Result, ConnectionError> { set_device_modifier_mapping(self, device_id, keymaps) } @@ -15042,7 +16398,7 @@ pub trait ConnectionExt: RequestConnection { { get_device_button_mapping(self, device_id) } - fn xinput_set_device_button_mapping<'c>(&'c self, device_id: u8, map: &[u8]) -> Result, ConnectionError> + fn xinput_set_device_button_mapping<'c, 'input>(&'c self, device_id: u8, map: &'input [u8]) -> Result, ConnectionError> { set_device_button_mapping(self, device_id, map) } @@ -15054,7 +16410,7 @@ pub trait ConnectionExt: RequestConnection { { device_bell(self, device_id, feedback_id, feedback_class, percent) } - fn xinput_set_device_valuators<'c>(&'c self, device_id: u8, first_valuator: u8, valuators: &[i32]) -> Result, ConnectionError> + fn xinput_set_device_valuators<'c, 'input>(&'c self, device_id: u8, first_valuator: u8, valuators: &'input [i32]) -> Result, ConnectionError> { set_device_valuators(self, device_id, first_valuator, valuators) } @@ -15070,7 +16426,7 @@ pub trait ConnectionExt: RequestConnection { { list_device_properties(self, device_id) } - fn xinput_change_device_property<'c>(&'c self, property: xproto::Atom, type_: xproto::Atom, device_id: u8, mode: xproto::PropMode, num_items: u32, items: &ChangeDevicePropertyAux) -> Result, ConnectionError> + fn xinput_change_device_property<'c, 'input>(&'c self, property: xproto::Atom, type_: xproto::Atom, device_id: u8, mode: xproto::PropMode, num_items: u32, items: &'input ChangeDevicePropertyAux) -> Result, ConnectionError> { change_device_property(self, property, type_, device_id, mode, num_items, items) } @@ -15100,7 +16456,7 @@ pub trait ConnectionExt: RequestConnection { { xi_change_cursor(self, window, cursor, deviceid) } - fn xinput_xi_change_hierarchy<'c>(&'c self, changes: &[HierarchyChange]) -> Result, ConnectionError> + fn xinput_xi_change_hierarchy<'c, 'input>(&'c self, changes: &'input [HierarchyChange]) -> Result, ConnectionError> { xi_change_hierarchy(self, changes) } @@ -15114,7 +16470,7 @@ pub trait ConnectionExt: RequestConnection { { xi_get_client_pointer(self, window) } - fn xinput_xi_select_events<'c>(&'c self, window: xproto::Window, masks: &[EventMask]) -> Result, ConnectionError> + fn xinput_xi_select_events<'c, 'input>(&'c self, window: xproto::Window, masks: &'input [EventMask]) -> Result, ConnectionError> { xi_select_events(self, window, masks) } @@ -15141,7 +16497,7 @@ pub trait ConnectionExt: RequestConnection { { xi_get_focus(self, deviceid) } - fn xinput_xi_grab_device<'c, A, B>(&'c self, window: xproto::Window, time: A, cursor: xproto::Cursor, deviceid: B, mode: xproto::GrabMode, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &[u32]) -> Result, ConnectionError> + fn xinput_xi_grab_device<'c, 'input, A, B>(&'c self, window: xproto::Window, time: A, cursor: xproto::Cursor, deviceid: B, mode: xproto::GrabMode, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &'input [u32]) -> Result, ConnectionError> where A: Into, B: Into, @@ -15162,14 +16518,14 @@ pub trait ConnectionExt: RequestConnection { { xi_allow_events(self, time, deviceid, event_mode, touchid, grab_window) } - fn xinput_xi_passive_grab_device<'c, A, B>(&'c self, time: A, grab_window: xproto::Window, cursor: xproto::Cursor, detail: u32, deviceid: B, grab_type: GrabType, grab_mode: GrabMode22, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &[u32], modifiers: &[u32]) -> Result, ConnectionError> + fn xinput_xi_passive_grab_device<'c, 'input, A, B>(&'c self, time: A, grab_window: xproto::Window, cursor: xproto::Cursor, detail: u32, deviceid: B, grab_type: GrabType, grab_mode: GrabMode22, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &'input [u32], modifiers: &'input [u32]) -> Result, ConnectionError> where A: Into, B: Into, { xi_passive_grab_device(self, time, grab_window, cursor, detail, deviceid, grab_type, grab_mode, paired_device_mode, owner_events, mask, modifiers) } - fn xinput_xi_passive_ungrab_device<'c, A>(&'c self, grab_window: xproto::Window, detail: u32, deviceid: A, grab_type: GrabType, modifiers: &[u32]) -> Result, ConnectionError> + fn xinput_xi_passive_ungrab_device<'c, 'input, A>(&'c self, grab_window: xproto::Window, detail: u32, deviceid: A, grab_type: GrabType, modifiers: &'input [u32]) -> Result, ConnectionError> where A: Into, { @@ -15181,7 +16537,7 @@ pub trait ConnectionExt: RequestConnection { { xi_list_properties(self, deviceid) } - fn xinput_xi_change_property<'c, A>(&'c self, deviceid: A, mode: xproto::PropMode, property: xproto::Atom, type_: xproto::Atom, num_items: u32, items: &XIChangePropertyAux) -> Result, ConnectionError> + fn xinput_xi_change_property<'c, 'input, A>(&'c self, deviceid: A, mode: xproto::PropMode, property: xproto::Atom, type_: xproto::Atom, num_items: u32, items: &'input XIChangePropertyAux) -> Result, ConnectionError> where A: Into, { @@ -15203,11 +16559,11 @@ pub trait ConnectionExt: RequestConnection { { xi_get_selected_events(self, window) } - fn xinput_xi_barrier_release_pointer<'c>(&'c self, barriers: &[BarrierReleasePointerInfo]) -> Result, ConnectionError> + fn xinput_xi_barrier_release_pointer<'c, 'input>(&'c self, barriers: &'input [BarrierReleasePointerInfo]) -> Result, ConnectionError> { xi_barrier_release_pointer(self, barriers) } - fn xinput_send_extension_event<'c>(&'c self, destination: xproto::Window, device_id: u8, propagate: bool, events: &[EventForSend], classes: &[EventClass]) -> Result, ConnectionError> + fn xinput_send_extension_event<'c, 'input>(&'c self, destination: xproto::Window, device_id: u8, propagate: bool, events: &'input [EventForSend], classes: &'input [EventClass]) -> Result, ConnectionError> { send_extension_event(self, destination, device_id, propagate, events, classes) } diff --git a/src/protocol/xkb.rs b/src/protocol/xkb.rs index 99633ad6..1a333640 100644 --- a/src/protocol/xkb.rs +++ b/src/protocol/xkb.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -6309,30 +6309,50 @@ impl From for Action { /// Opcode for the UseExtension request pub const USE_EXTENSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UseExtensionRequest { + pub wanted_major: u16, + pub wanted_minor: u16, +} +impl UseExtensionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let wanted_major_bytes = self.wanted_major.serialize(); + let wanted_minor_bytes = self.wanted_minor.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + USE_EXTENSION_REQUEST, + 0, + 0, + wanted_major_bytes[0], + wanted_major_bytes[1], + wanted_minor_bytes[0], + wanted_minor_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn use_extension(conn: &Conn, wanted_major: u16, wanted_minor: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let wanted_major_bytes = wanted_major.serialize(); - let wanted_minor_bytes = wanted_minor.serialize(); - let mut request0 = [ - extension_information.major_opcode, - USE_EXTENSION_REQUEST, - 0, - 0, - wanted_major_bytes[0], - wanted_major_bytes[1], - wanted_minor_bytes[0], - wanted_minor_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UseExtensionRequest { + wanted_major, + wanted_minor, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -6364,8 +6384,6 @@ impl TryFrom<&[u8]> for UseExtensionReply { } } -/// Opcode for the SelectEvents request -pub const SELECT_EVENTS_REQUEST: u8 = 1; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct SelectEventsAuxBitcase1 { pub affect_new_keyboard: u16, @@ -6785,7 +6803,63 @@ impl SelectEventsAux { } } -pub fn select_events<'c, Conn, A, B, C, D, E>(conn: &'c Conn, device_spec: DeviceSpec, affect_which: A, clear: B, select_all: C, affect_map: D, map: E, details: &SelectEventsAux) -> Result, ConnectionError> +/// Opcode for the SelectEvents request +pub const SELECT_EVENTS_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectEventsRequest<'input> { + pub device_spec: DeviceSpec, + pub affect_which: u16, + pub clear: u16, + pub select_all: u16, + pub affect_map: u16, + pub map: u16, + pub details: &'input SelectEventsAux, +} +impl<'input> SelectEventsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let affect_which_bytes = self.affect_which.serialize(); + let clear_bytes = self.clear.serialize(); + let select_all_bytes = self.select_all.serialize(); + let affect_map_bytes = self.affect_map.serialize(); + let map_bytes = self.map.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_EVENTS_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + affect_which_bytes[0], + affect_which_bytes[1], + clear_bytes[0], + clear_bytes[1], + select_all_bytes[0], + select_all_bytes[1], + affect_map_bytes[0], + affect_map_bytes[1], + map_bytes[0], + map_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let details_bytes = self.details.serialize(self.affect_which, self.clear, self.select_all); + let length_so_far = length_so_far + details_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), details_bytes.into(), padding0.into()], vec![])) + } +} +pub fn select_events<'c, 'input, Conn, A, B, C, D, E>(conn: &'c Conn, device_spec: DeviceSpec, affect_which: A, clear: B, select_all: C, affect_map: D, map: E, details: &'input SelectEventsAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, @@ -6794,130 +6868,160 @@ where D: Into, E: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let affect_which: u16 = affect_which.into(); let clear: u16 = clear.into(); let select_all: u16 = select_all.into(); let affect_map: u16 = affect_map.into(); let map: u16 = map.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let affect_which_bytes = affect_which.serialize(); - let clear_bytes = clear.serialize(); - let select_all_bytes = select_all.serialize(); - let affect_map_bytes = affect_map.serialize(); - let map_bytes = map.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_EVENTS_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - affect_which_bytes[0], - affect_which_bytes[1], - clear_bytes[0], - clear_bytes[1], - select_all_bytes[0], - select_all_bytes[1], - affect_map_bytes[0], - affect_map_bytes[1], - map_bytes[0], - map_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let details_bytes = details.serialize(affect_which, clear, select_all); - let length_so_far = length_so_far + details_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&details_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SelectEventsRequest { + device_spec, + affect_which, + clear, + select_all, + affect_map, + map, + details, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the Bell request pub const BELL_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct BellRequest { + pub device_spec: DeviceSpec, + pub bell_class: BellClassSpec, + pub bell_id: IDSpec, + pub percent: i8, + pub force_sound: bool, + pub event_only: bool, + pub pitch: i16, + pub duration: i16, + pub name: xproto::Atom, + pub window: xproto::Window, +} +impl BellRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let bell_class_bytes = self.bell_class.serialize(); + let bell_id_bytes = self.bell_id.serialize(); + let percent_bytes = self.percent.serialize(); + let force_sound_bytes = self.force_sound.serialize(); + let event_only_bytes = self.event_only.serialize(); + let pitch_bytes = self.pitch.serialize(); + let duration_bytes = self.duration.serialize(); + let name_bytes = self.name.serialize(); + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + BELL_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + bell_class_bytes[0], + bell_class_bytes[1], + bell_id_bytes[0], + bell_id_bytes[1], + percent_bytes[0], + force_sound_bytes[0], + event_only_bytes[0], + 0, + pitch_bytes[0], + pitch_bytes[1], + duration_bytes[0], + duration_bytes[1], + 0, + 0, + name_bytes[0], + name_bytes[1], + name_bytes[2], + name_bytes[3], + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn bell(conn: &Conn, device_spec: DeviceSpec, bell_class: BellClassSpec, bell_id: IDSpec, percent: i8, force_sound: bool, event_only: bool, pitch: i16, duration: i16, name: xproto::Atom, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let bell_class_bytes = bell_class.serialize(); - let bell_id_bytes = bell_id.serialize(); - let percent_bytes = percent.serialize(); - let force_sound_bytes = force_sound.serialize(); - let event_only_bytes = event_only.serialize(); - let pitch_bytes = pitch.serialize(); - let duration_bytes = duration.serialize(); - let name_bytes = name.serialize(); - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - BELL_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - bell_class_bytes[0], - bell_class_bytes[1], - bell_id_bytes[0], - bell_id_bytes[1], - percent_bytes[0], - force_sound_bytes[0], - event_only_bytes[0], - 0, - pitch_bytes[0], - pitch_bytes[1], - duration_bytes[0], - duration_bytes[1], - 0, - 0, - name_bytes[0], - name_bytes[1], - name_bytes[2], - name_bytes[3], - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = BellRequest { + device_spec, + bell_class, + bell_id, + percent, + force_sound, + event_only, + pitch, + duration, + name, + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetState request pub const GET_STATE_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetStateRequest { + pub device_spec: DeviceSpec, +} +impl GetStateRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_STATE_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_state(conn: &Conn, device_spec: DeviceSpec) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_STATE_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetStateRequest { + device_spec, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -6978,6 +7082,59 @@ impl TryFrom<&[u8]> for GetStateReply { /// Opcode for the LatchLockState request pub const LATCH_LOCK_STATE_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct LatchLockStateRequest { + pub device_spec: DeviceSpec, + pub affect_mod_locks: u8, + pub mod_locks: u8, + pub lock_group: bool, + pub group_lock: Group, + pub affect_mod_latches: u8, + pub latch_group: bool, + pub group_latch: u16, +} +impl LatchLockStateRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let affect_mod_locks_bytes = self.affect_mod_locks.serialize(); + let mod_locks_bytes = self.mod_locks.serialize(); + let lock_group_bytes = self.lock_group.serialize(); + let group_lock_bytes = u8::from(self.group_lock).serialize(); + let affect_mod_latches_bytes = self.affect_mod_latches.serialize(); + let latch_group_bytes = self.latch_group.serialize(); + let group_latch_bytes = self.group_latch.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + LATCH_LOCK_STATE_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + affect_mod_locks_bytes[0], + mod_locks_bytes[0], + lock_group_bytes[0], + group_lock_bytes[0], + affect_mod_latches_bytes[0], + 0, + 0, + latch_group_bytes[0], + group_latch_bytes[0], + group_latch_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn latch_lock_state(conn: &Conn, device_spec: DeviceSpec, affect_mod_locks: A, mod_locks: B, lock_group: bool, group_lock: Group, affect_mod_latches: C, latch_group: bool, group_latch: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -6985,70 +7142,67 @@ where B: Into, C: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let affect_mod_locks: u8 = affect_mod_locks.into(); let mod_locks: u8 = mod_locks.into(); let affect_mod_latches: u8 = affect_mod_latches.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let affect_mod_locks_bytes = affect_mod_locks.serialize(); - let mod_locks_bytes = mod_locks.serialize(); - let lock_group_bytes = lock_group.serialize(); - let group_lock_bytes = u8::from(group_lock).serialize(); - let affect_mod_latches_bytes = affect_mod_latches.serialize(); - let latch_group_bytes = latch_group.serialize(); - let group_latch_bytes = group_latch.serialize(); - let mut request0 = [ - extension_information.major_opcode, - LATCH_LOCK_STATE_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - affect_mod_locks_bytes[0], - mod_locks_bytes[0], - lock_group_bytes[0], - group_lock_bytes[0], - affect_mod_latches_bytes[0], - 0, - 0, - latch_group_bytes[0], - group_latch_bytes[0], - group_latch_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = LatchLockStateRequest { + device_spec, + affect_mod_locks, + mod_locks, + lock_group, + group_lock, + affect_mod_latches, + latch_group, + group_latch, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetControls request pub const GET_CONTROLS_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetControlsRequest { + pub device_spec: DeviceSpec, +} +impl GetControlsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CONTROLS_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_controls(conn: &Conn, device_spec: DeviceSpec) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CONTROLS_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetControlsRequest { + device_spec, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -7132,7 +7286,156 @@ impl TryFrom<&[u8]> for GetControlsReply { /// Opcode for the SetControls request pub const SET_CONTROLS_REQUEST: u8 = 7; -pub fn set_controls<'c, Conn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(conn: &'c Conn, device_spec: DeviceSpec, affect_internal_real_mods: A, internal_real_mods: B, affect_ignore_lock_real_mods: C, ignore_lock_real_mods: D, affect_internal_virtual_mods: E, internal_virtual_mods: F, affect_ignore_lock_virtual_mods: G, ignore_lock_virtual_mods: H, mouse_keys_dflt_btn: u8, groups_wrap: u8, access_x_options: I, affect_enabled_controls: J, enabled_controls: K, change_controls: L, repeat_delay: u16, repeat_interval: u16, slow_keys_delay: u16, debounce_delay: u16, mouse_keys_delay: u16, mouse_keys_interval: u16, mouse_keys_time_to_max: u16, mouse_keys_max_speed: u16, mouse_keys_curve: i16, access_x_timeout: u16, access_x_timeout_mask: M, access_x_timeout_values: N, access_x_timeout_options_mask: O, access_x_timeout_options_values: P, per_key_repeat: &[u8; 32]) -> Result, ConnectionError> +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetControlsRequest<'input> { + pub device_spec: DeviceSpec, + pub affect_internal_real_mods: u8, + pub internal_real_mods: u8, + pub affect_ignore_lock_real_mods: u8, + pub ignore_lock_real_mods: u8, + pub affect_internal_virtual_mods: u16, + pub internal_virtual_mods: u16, + pub affect_ignore_lock_virtual_mods: u16, + pub ignore_lock_virtual_mods: u16, + pub mouse_keys_dflt_btn: u8, + pub groups_wrap: u8, + pub access_x_options: u16, + pub affect_enabled_controls: u32, + pub enabled_controls: u32, + pub change_controls: u32, + pub repeat_delay: u16, + pub repeat_interval: u16, + pub slow_keys_delay: u16, + pub debounce_delay: u16, + pub mouse_keys_delay: u16, + pub mouse_keys_interval: u16, + pub mouse_keys_time_to_max: u16, + pub mouse_keys_max_speed: u16, + pub mouse_keys_curve: i16, + pub access_x_timeout: u16, + pub access_x_timeout_mask: u32, + pub access_x_timeout_values: u32, + pub access_x_timeout_options_mask: u16, + pub access_x_timeout_options_values: u16, + pub per_key_repeat: &'input [u8; 32], +} +impl<'input> SetControlsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let affect_internal_real_mods_bytes = self.affect_internal_real_mods.serialize(); + let internal_real_mods_bytes = self.internal_real_mods.serialize(); + let affect_ignore_lock_real_mods_bytes = self.affect_ignore_lock_real_mods.serialize(); + let ignore_lock_real_mods_bytes = self.ignore_lock_real_mods.serialize(); + let affect_internal_virtual_mods_bytes = self.affect_internal_virtual_mods.serialize(); + let internal_virtual_mods_bytes = self.internal_virtual_mods.serialize(); + let affect_ignore_lock_virtual_mods_bytes = self.affect_ignore_lock_virtual_mods.serialize(); + let ignore_lock_virtual_mods_bytes = self.ignore_lock_virtual_mods.serialize(); + let mouse_keys_dflt_btn_bytes = self.mouse_keys_dflt_btn.serialize(); + let groups_wrap_bytes = self.groups_wrap.serialize(); + let access_x_options_bytes = self.access_x_options.serialize(); + let affect_enabled_controls_bytes = self.affect_enabled_controls.serialize(); + let enabled_controls_bytes = self.enabled_controls.serialize(); + let change_controls_bytes = self.change_controls.serialize(); + let repeat_delay_bytes = self.repeat_delay.serialize(); + let repeat_interval_bytes = self.repeat_interval.serialize(); + let slow_keys_delay_bytes = self.slow_keys_delay.serialize(); + let debounce_delay_bytes = self.debounce_delay.serialize(); + let mouse_keys_delay_bytes = self.mouse_keys_delay.serialize(); + let mouse_keys_interval_bytes = self.mouse_keys_interval.serialize(); + let mouse_keys_time_to_max_bytes = self.mouse_keys_time_to_max.serialize(); + let mouse_keys_max_speed_bytes = self.mouse_keys_max_speed.serialize(); + let mouse_keys_curve_bytes = self.mouse_keys_curve.serialize(); + let access_x_timeout_bytes = self.access_x_timeout.serialize(); + let access_x_timeout_mask_bytes = self.access_x_timeout_mask.serialize(); + let access_x_timeout_values_bytes = self.access_x_timeout_values.serialize(); + let access_x_timeout_options_mask_bytes = self.access_x_timeout_options_mask.serialize(); + let access_x_timeout_options_values_bytes = self.access_x_timeout_options_values.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_CONTROLS_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + affect_internal_real_mods_bytes[0], + internal_real_mods_bytes[0], + affect_ignore_lock_real_mods_bytes[0], + ignore_lock_real_mods_bytes[0], + affect_internal_virtual_mods_bytes[0], + affect_internal_virtual_mods_bytes[1], + internal_virtual_mods_bytes[0], + internal_virtual_mods_bytes[1], + affect_ignore_lock_virtual_mods_bytes[0], + affect_ignore_lock_virtual_mods_bytes[1], + ignore_lock_virtual_mods_bytes[0], + ignore_lock_virtual_mods_bytes[1], + mouse_keys_dflt_btn_bytes[0], + groups_wrap_bytes[0], + access_x_options_bytes[0], + access_x_options_bytes[1], + 0, + 0, + affect_enabled_controls_bytes[0], + affect_enabled_controls_bytes[1], + affect_enabled_controls_bytes[2], + affect_enabled_controls_bytes[3], + enabled_controls_bytes[0], + enabled_controls_bytes[1], + enabled_controls_bytes[2], + enabled_controls_bytes[3], + change_controls_bytes[0], + change_controls_bytes[1], + change_controls_bytes[2], + change_controls_bytes[3], + repeat_delay_bytes[0], + repeat_delay_bytes[1], + repeat_interval_bytes[0], + repeat_interval_bytes[1], + slow_keys_delay_bytes[0], + slow_keys_delay_bytes[1], + debounce_delay_bytes[0], + debounce_delay_bytes[1], + mouse_keys_delay_bytes[0], + mouse_keys_delay_bytes[1], + mouse_keys_interval_bytes[0], + mouse_keys_interval_bytes[1], + mouse_keys_time_to_max_bytes[0], + mouse_keys_time_to_max_bytes[1], + mouse_keys_max_speed_bytes[0], + mouse_keys_max_speed_bytes[1], + mouse_keys_curve_bytes[0], + mouse_keys_curve_bytes[1], + access_x_timeout_bytes[0], + access_x_timeout_bytes[1], + access_x_timeout_mask_bytes[0], + access_x_timeout_mask_bytes[1], + access_x_timeout_mask_bytes[2], + access_x_timeout_mask_bytes[3], + access_x_timeout_values_bytes[0], + access_x_timeout_values_bytes[1], + access_x_timeout_values_bytes[2], + access_x_timeout_values_bytes[3], + access_x_timeout_options_mask_bytes[0], + access_x_timeout_options_mask_bytes[1], + access_x_timeout_options_values_bytes[0], + access_x_timeout_options_values_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.per_key_repeat[..]).len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.per_key_repeat[..]).into()], vec![])) + } +} +pub fn set_controls<'c, 'input, Conn, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(conn: &'c Conn, device_spec: DeviceSpec, affect_internal_real_mods: A, internal_real_mods: B, affect_ignore_lock_real_mods: C, ignore_lock_real_mods: D, affect_internal_virtual_mods: E, internal_virtual_mods: F, affect_ignore_lock_virtual_mods: G, ignore_lock_virtual_mods: H, mouse_keys_dflt_btn: u8, groups_wrap: u8, access_x_options: I, affect_enabled_controls: J, enabled_controls: K, change_controls: L, repeat_delay: u16, repeat_interval: u16, slow_keys_delay: u16, debounce_delay: u16, mouse_keys_delay: u16, mouse_keys_interval: u16, mouse_keys_time_to_max: u16, mouse_keys_max_speed: u16, mouse_keys_curve: i16, access_x_timeout: u16, access_x_timeout_mask: M, access_x_timeout_values: N, access_x_timeout_options_mask: O, access_x_timeout_options_values: P, per_key_repeat: &'input [u8; 32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, @@ -7152,8 +7455,6 @@ where O: Into, P: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let affect_internal_real_mods: u8 = affect_internal_real_mods.into(); let internal_real_mods: u8 = internal_real_mods.into(); let affect_ignore_lock_real_mods: u8 = affect_ignore_lock_real_mods.into(); @@ -7170,116 +7471,130 @@ where let access_x_timeout_values: u32 = access_x_timeout_values.into(); let access_x_timeout_options_mask: u16 = access_x_timeout_options_mask.into(); let access_x_timeout_options_values: u16 = access_x_timeout_options_values.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let affect_internal_real_mods_bytes = affect_internal_real_mods.serialize(); - let internal_real_mods_bytes = internal_real_mods.serialize(); - let affect_ignore_lock_real_mods_bytes = affect_ignore_lock_real_mods.serialize(); - let ignore_lock_real_mods_bytes = ignore_lock_real_mods.serialize(); - let affect_internal_virtual_mods_bytes = affect_internal_virtual_mods.serialize(); - let internal_virtual_mods_bytes = internal_virtual_mods.serialize(); - let affect_ignore_lock_virtual_mods_bytes = affect_ignore_lock_virtual_mods.serialize(); - let ignore_lock_virtual_mods_bytes = ignore_lock_virtual_mods.serialize(); - let mouse_keys_dflt_btn_bytes = mouse_keys_dflt_btn.serialize(); - let groups_wrap_bytes = groups_wrap.serialize(); - let access_x_options_bytes = access_x_options.serialize(); - let affect_enabled_controls_bytes = affect_enabled_controls.serialize(); - let enabled_controls_bytes = enabled_controls.serialize(); - let change_controls_bytes = change_controls.serialize(); - let repeat_delay_bytes = repeat_delay.serialize(); - let repeat_interval_bytes = repeat_interval.serialize(); - let slow_keys_delay_bytes = slow_keys_delay.serialize(); - let debounce_delay_bytes = debounce_delay.serialize(); - let mouse_keys_delay_bytes = mouse_keys_delay.serialize(); - let mouse_keys_interval_bytes = mouse_keys_interval.serialize(); - let mouse_keys_time_to_max_bytes = mouse_keys_time_to_max.serialize(); - let mouse_keys_max_speed_bytes = mouse_keys_max_speed.serialize(); - let mouse_keys_curve_bytes = mouse_keys_curve.serialize(); - let access_x_timeout_bytes = access_x_timeout.serialize(); - let access_x_timeout_mask_bytes = access_x_timeout_mask.serialize(); - let access_x_timeout_values_bytes = access_x_timeout_values.serialize(); - let access_x_timeout_options_mask_bytes = access_x_timeout_options_mask.serialize(); - let access_x_timeout_options_values_bytes = access_x_timeout_options_values.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_CONTROLS_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - affect_internal_real_mods_bytes[0], - internal_real_mods_bytes[0], - affect_ignore_lock_real_mods_bytes[0], - ignore_lock_real_mods_bytes[0], - affect_internal_virtual_mods_bytes[0], - affect_internal_virtual_mods_bytes[1], - internal_virtual_mods_bytes[0], - internal_virtual_mods_bytes[1], - affect_ignore_lock_virtual_mods_bytes[0], - affect_ignore_lock_virtual_mods_bytes[1], - ignore_lock_virtual_mods_bytes[0], - ignore_lock_virtual_mods_bytes[1], - mouse_keys_dflt_btn_bytes[0], - groups_wrap_bytes[0], - access_x_options_bytes[0], - access_x_options_bytes[1], - 0, - 0, - affect_enabled_controls_bytes[0], - affect_enabled_controls_bytes[1], - affect_enabled_controls_bytes[2], - affect_enabled_controls_bytes[3], - enabled_controls_bytes[0], - enabled_controls_bytes[1], - enabled_controls_bytes[2], - enabled_controls_bytes[3], - change_controls_bytes[0], - change_controls_bytes[1], - change_controls_bytes[2], - change_controls_bytes[3], - repeat_delay_bytes[0], - repeat_delay_bytes[1], - repeat_interval_bytes[0], - repeat_interval_bytes[1], - slow_keys_delay_bytes[0], - slow_keys_delay_bytes[1], - debounce_delay_bytes[0], - debounce_delay_bytes[1], - mouse_keys_delay_bytes[0], - mouse_keys_delay_bytes[1], - mouse_keys_interval_bytes[0], - mouse_keys_interval_bytes[1], - mouse_keys_time_to_max_bytes[0], - mouse_keys_time_to_max_bytes[1], - mouse_keys_max_speed_bytes[0], - mouse_keys_max_speed_bytes[1], - mouse_keys_curve_bytes[0], - mouse_keys_curve_bytes[1], - access_x_timeout_bytes[0], - access_x_timeout_bytes[1], - access_x_timeout_mask_bytes[0], - access_x_timeout_mask_bytes[1], - access_x_timeout_mask_bytes[2], - access_x_timeout_mask_bytes[3], - access_x_timeout_values_bytes[0], - access_x_timeout_values_bytes[1], - access_x_timeout_values_bytes[2], - access_x_timeout_values_bytes[3], - access_x_timeout_options_mask_bytes[0], - access_x_timeout_options_mask_bytes[1], - access_x_timeout_options_values_bytes[0], - access_x_timeout_options_values_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + per_key_repeat.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(per_key_repeat)], vec![])?) + let request0 = SetControlsRequest { + device_spec, + affect_internal_real_mods, + internal_real_mods, + affect_ignore_lock_real_mods, + ignore_lock_real_mods, + affect_internal_virtual_mods, + internal_virtual_mods, + affect_ignore_lock_virtual_mods, + ignore_lock_virtual_mods, + mouse_keys_dflt_btn, + groups_wrap, + access_x_options, + affect_enabled_controls, + enabled_controls, + change_controls, + repeat_delay, + repeat_interval, + slow_keys_delay, + debounce_delay, + mouse_keys_delay, + mouse_keys_interval, + mouse_keys_time_to_max, + mouse_keys_max_speed, + mouse_keys_curve, + access_x_timeout, + access_x_timeout_mask, + access_x_timeout_values, + access_x_timeout_options_mask, + access_x_timeout_options_values, + per_key_repeat, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetMap request pub const GET_MAP_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMapRequest { + pub device_spec: DeviceSpec, + pub full: u16, + pub partial: u16, + pub first_type: u8, + pub n_types: u8, + pub first_key_sym: xproto::Keycode, + pub n_key_syms: u8, + pub first_key_action: xproto::Keycode, + pub n_key_actions: u8, + pub first_key_behavior: xproto::Keycode, + pub n_key_behaviors: u8, + pub virtual_mods: u16, + pub first_key_explicit: xproto::Keycode, + pub n_key_explicit: u8, + pub first_mod_map_key: xproto::Keycode, + pub n_mod_map_keys: u8, + pub first_v_mod_map_key: xproto::Keycode, + pub n_v_mod_map_keys: u8, +} +impl GetMapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let full_bytes = self.full.serialize(); + let partial_bytes = self.partial.serialize(); + let first_type_bytes = self.first_type.serialize(); + let n_types_bytes = self.n_types.serialize(); + let first_key_sym_bytes = self.first_key_sym.serialize(); + let n_key_syms_bytes = self.n_key_syms.serialize(); + let first_key_action_bytes = self.first_key_action.serialize(); + let n_key_actions_bytes = self.n_key_actions.serialize(); + let first_key_behavior_bytes = self.first_key_behavior.serialize(); + let n_key_behaviors_bytes = self.n_key_behaviors.serialize(); + let virtual_mods_bytes = self.virtual_mods.serialize(); + let first_key_explicit_bytes = self.first_key_explicit.serialize(); + let n_key_explicit_bytes = self.n_key_explicit.serialize(); + let first_mod_map_key_bytes = self.first_mod_map_key.serialize(); + let n_mod_map_keys_bytes = self.n_mod_map_keys.serialize(); + let first_v_mod_map_key_bytes = self.first_v_mod_map_key.serialize(); + let n_v_mod_map_keys_bytes = self.n_v_mod_map_keys.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_MAP_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + full_bytes[0], + full_bytes[1], + partial_bytes[0], + partial_bytes[1], + first_type_bytes[0], + n_types_bytes[0], + first_key_sym_bytes[0], + n_key_syms_bytes[0], + first_key_action_bytes[0], + n_key_actions_bytes[0], + first_key_behavior_bytes[0], + n_key_behaviors_bytes[0], + virtual_mods_bytes[0], + virtual_mods_bytes[1], + first_key_explicit_bytes[0], + n_key_explicit_bytes[0], + first_mod_map_key_bytes[0], + n_mod_map_keys_bytes[0], + first_v_mod_map_key_bytes[0], + n_v_mod_map_keys_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_map(conn: &Conn, device_spec: DeviceSpec, full: A, partial: B, first_type: u8, n_types: u8, first_key_sym: xproto::Keycode, n_key_syms: u8, first_key_action: xproto::Keycode, n_key_actions: u8, first_key_behavior: xproto::Keycode, n_key_behaviors: u8, virtual_mods: C, first_key_explicit: xproto::Keycode, n_key_explicit: u8, first_mod_map_key: xproto::Keycode, n_mod_map_keys: u8, first_v_mod_map_key: xproto::Keycode, n_v_mod_map_keys: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -7287,65 +7602,32 @@ where B: Into, C: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let full: u16 = full.into(); let partial: u16 = partial.into(); let virtual_mods: u16 = virtual_mods.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let full_bytes = full.serialize(); - let partial_bytes = partial.serialize(); - let first_type_bytes = first_type.serialize(); - let n_types_bytes = n_types.serialize(); - let first_key_sym_bytes = first_key_sym.serialize(); - let n_key_syms_bytes = n_key_syms.serialize(); - let first_key_action_bytes = first_key_action.serialize(); - let n_key_actions_bytes = n_key_actions.serialize(); - let first_key_behavior_bytes = first_key_behavior.serialize(); - let n_key_behaviors_bytes = n_key_behaviors.serialize(); - let virtual_mods_bytes = virtual_mods.serialize(); - let first_key_explicit_bytes = first_key_explicit.serialize(); - let n_key_explicit_bytes = n_key_explicit.serialize(); - let first_mod_map_key_bytes = first_mod_map_key.serialize(); - let n_mod_map_keys_bytes = n_mod_map_keys.serialize(); - let first_v_mod_map_key_bytes = first_v_mod_map_key.serialize(); - let n_v_mod_map_keys_bytes = n_v_mod_map_keys.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_MAP_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - full_bytes[0], - full_bytes[1], - partial_bytes[0], - partial_bytes[1], - first_type_bytes[0], - n_types_bytes[0], - first_key_sym_bytes[0], - n_key_syms_bytes[0], - first_key_action_bytes[0], - n_key_actions_bytes[0], - first_key_behavior_bytes[0], - n_key_behaviors_bytes[0], - virtual_mods_bytes[0], - virtual_mods_bytes[1], - first_key_explicit_bytes[0], - n_key_explicit_bytes[0], - first_mod_map_key_bytes[0], - n_mod_map_keys_bytes[0], - first_v_mod_map_key_bytes[0], - n_v_mod_map_keys_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMapRequest { + device_spec, + full, + partial, + first_type, + n_types, + first_key_sym, + n_key_syms, + first_key_action, + n_key_actions, + first_key_behavior, + n_key_behaviors, + virtual_mods, + first_key_explicit, + n_key_explicit, + first_mod_map_key, + n_mod_map_keys, + first_v_mod_map_key, + n_v_mod_map_keys, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone)] @@ -7544,8 +7826,6 @@ impl TryFrom<&[u8]> for GetMapReply { } } -/// Opcode for the SetMap request -pub const SET_MAP_REQUEST: u8 = 9; #[derive(Debug, Clone)] pub struct SetMapAuxBitcase3 { pub actions_count: Vec, @@ -7697,128 +7977,224 @@ impl SetMapAux { } } -pub fn set_map<'c, Conn, A, B>(conn: &'c Conn, device_spec: DeviceSpec, flags: A, min_key_code: xproto::Keycode, max_key_code: xproto::Keycode, first_type: u8, n_types: u8, first_key_sym: xproto::Keycode, n_key_syms: u8, total_syms: u16, first_key_action: xproto::Keycode, n_key_actions: u8, total_actions: u16, first_key_behavior: xproto::Keycode, n_key_behaviors: u8, total_key_behaviors: u8, first_key_explicit: xproto::Keycode, n_key_explicit: u8, total_key_explicit: u8, first_mod_map_key: xproto::Keycode, n_mod_map_keys: u8, total_mod_map_keys: u8, first_v_mod_map_key: xproto::Keycode, n_v_mod_map_keys: u8, total_v_mod_map_keys: u8, virtual_mods: B, values: &SetMapAux) -> Result, ConnectionError> +/// Opcode for the SetMap request +pub const SET_MAP_REQUEST: u8 = 9; +#[derive(Debug, Clone)] +pub struct SetMapRequest<'input> { + pub device_spec: DeviceSpec, + pub flags: u16, + pub min_key_code: xproto::Keycode, + pub max_key_code: xproto::Keycode, + pub first_type: u8, + pub n_types: u8, + pub first_key_sym: xproto::Keycode, + pub n_key_syms: u8, + pub total_syms: u16, + pub first_key_action: xproto::Keycode, + pub n_key_actions: u8, + pub total_actions: u16, + pub first_key_behavior: xproto::Keycode, + pub n_key_behaviors: u8, + pub total_key_behaviors: u8, + pub first_key_explicit: xproto::Keycode, + pub n_key_explicit: u8, + pub total_key_explicit: u8, + pub first_mod_map_key: xproto::Keycode, + pub n_mod_map_keys: u8, + pub total_mod_map_keys: u8, + pub first_v_mod_map_key: xproto::Keycode, + pub n_v_mod_map_keys: u8, + pub total_v_mod_map_keys: u8, + pub virtual_mods: u16, + pub values: &'input SetMapAux, +} +impl<'input> SetMapRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let present = u16::try_from(self.values.switch_expr()).unwrap(); + let present_bytes = present.serialize(); + let flags_bytes = self.flags.serialize(); + let min_key_code_bytes = self.min_key_code.serialize(); + let max_key_code_bytes = self.max_key_code.serialize(); + let first_type_bytes = self.first_type.serialize(); + let n_types_bytes = self.n_types.serialize(); + let first_key_sym_bytes = self.first_key_sym.serialize(); + let n_key_syms_bytes = self.n_key_syms.serialize(); + let total_syms_bytes = self.total_syms.serialize(); + let first_key_action_bytes = self.first_key_action.serialize(); + let n_key_actions_bytes = self.n_key_actions.serialize(); + let total_actions_bytes = self.total_actions.serialize(); + let first_key_behavior_bytes = self.first_key_behavior.serialize(); + let n_key_behaviors_bytes = self.n_key_behaviors.serialize(); + let total_key_behaviors_bytes = self.total_key_behaviors.serialize(); + let first_key_explicit_bytes = self.first_key_explicit.serialize(); + let n_key_explicit_bytes = self.n_key_explicit.serialize(); + let total_key_explicit_bytes = self.total_key_explicit.serialize(); + let first_mod_map_key_bytes = self.first_mod_map_key.serialize(); + let n_mod_map_keys_bytes = self.n_mod_map_keys.serialize(); + let total_mod_map_keys_bytes = self.total_mod_map_keys.serialize(); + let first_v_mod_map_key_bytes = self.first_v_mod_map_key.serialize(); + let n_v_mod_map_keys_bytes = self.n_v_mod_map_keys.serialize(); + let total_v_mod_map_keys_bytes = self.total_v_mod_map_keys.serialize(); + let virtual_mods_bytes = self.virtual_mods.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_MAP_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + present_bytes[0], + present_bytes[1], + flags_bytes[0], + flags_bytes[1], + min_key_code_bytes[0], + max_key_code_bytes[0], + first_type_bytes[0], + n_types_bytes[0], + first_key_sym_bytes[0], + n_key_syms_bytes[0], + total_syms_bytes[0], + total_syms_bytes[1], + first_key_action_bytes[0], + n_key_actions_bytes[0], + total_actions_bytes[0], + total_actions_bytes[1], + first_key_behavior_bytes[0], + n_key_behaviors_bytes[0], + total_key_behaviors_bytes[0], + first_key_explicit_bytes[0], + n_key_explicit_bytes[0], + total_key_explicit_bytes[0], + first_mod_map_key_bytes[0], + n_mod_map_keys_bytes[0], + total_mod_map_keys_bytes[0], + first_v_mod_map_key_bytes[0], + n_v_mod_map_keys_bytes[0], + total_v_mod_map_keys_bytes[0], + virtual_mods_bytes[0], + virtual_mods_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let values_bytes = self.values.serialize(present, self.n_types, self.n_key_syms, self.n_key_actions, self.total_actions, self.total_key_behaviors, self.virtual_mods, self.total_key_explicit, self.total_mod_map_keys, self.total_v_mod_map_keys); + let length_so_far = length_so_far + values_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), values_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_map<'c, 'input, Conn, A, B>(conn: &'c Conn, device_spec: DeviceSpec, flags: A, min_key_code: xproto::Keycode, max_key_code: xproto::Keycode, first_type: u8, n_types: u8, first_key_sym: xproto::Keycode, n_key_syms: u8, total_syms: u16, first_key_action: xproto::Keycode, n_key_actions: u8, total_actions: u16, first_key_behavior: xproto::Keycode, n_key_behaviors: u8, total_key_behaviors: u8, first_key_explicit: xproto::Keycode, n_key_explicit: u8, total_key_explicit: u8, first_mod_map_key: xproto::Keycode, n_mod_map_keys: u8, total_mod_map_keys: u8, first_v_mod_map_key: xproto::Keycode, n_v_mod_map_keys: u8, total_v_mod_map_keys: u8, virtual_mods: B, values: &'input SetMapAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let flags: u16 = flags.into(); let virtual_mods: u16 = virtual_mods.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let present = u16::try_from(values.switch_expr()).unwrap(); - let present_bytes = present.serialize(); - let flags_bytes = flags.serialize(); - let min_key_code_bytes = min_key_code.serialize(); - let max_key_code_bytes = max_key_code.serialize(); - let first_type_bytes = first_type.serialize(); - let n_types_bytes = n_types.serialize(); - let first_key_sym_bytes = first_key_sym.serialize(); - let n_key_syms_bytes = n_key_syms.serialize(); - let total_syms_bytes = total_syms.serialize(); - let first_key_action_bytes = first_key_action.serialize(); - let n_key_actions_bytes = n_key_actions.serialize(); - let total_actions_bytes = total_actions.serialize(); - let first_key_behavior_bytes = first_key_behavior.serialize(); - let n_key_behaviors_bytes = n_key_behaviors.serialize(); - let total_key_behaviors_bytes = total_key_behaviors.serialize(); - let first_key_explicit_bytes = first_key_explicit.serialize(); - let n_key_explicit_bytes = n_key_explicit.serialize(); - let total_key_explicit_bytes = total_key_explicit.serialize(); - let first_mod_map_key_bytes = first_mod_map_key.serialize(); - let n_mod_map_keys_bytes = n_mod_map_keys.serialize(); - let total_mod_map_keys_bytes = total_mod_map_keys.serialize(); - let first_v_mod_map_key_bytes = first_v_mod_map_key.serialize(); - let n_v_mod_map_keys_bytes = n_v_mod_map_keys.serialize(); - let total_v_mod_map_keys_bytes = total_v_mod_map_keys.serialize(); - let virtual_mods_bytes = virtual_mods.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_MAP_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - present_bytes[0], - present_bytes[1], - flags_bytes[0], - flags_bytes[1], - min_key_code_bytes[0], - max_key_code_bytes[0], - first_type_bytes[0], - n_types_bytes[0], - first_key_sym_bytes[0], - n_key_syms_bytes[0], - total_syms_bytes[0], - total_syms_bytes[1], - first_key_action_bytes[0], - n_key_actions_bytes[0], - total_actions_bytes[0], - total_actions_bytes[1], - first_key_behavior_bytes[0], - n_key_behaviors_bytes[0], - total_key_behaviors_bytes[0], - first_key_explicit_bytes[0], - n_key_explicit_bytes[0], - total_key_explicit_bytes[0], - first_mod_map_key_bytes[0], - n_mod_map_keys_bytes[0], - total_mod_map_keys_bytes[0], - first_v_mod_map_key_bytes[0], - n_v_mod_map_keys_bytes[0], - total_v_mod_map_keys_bytes[0], - virtual_mods_bytes[0], - virtual_mods_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let values_bytes = values.serialize(present, n_types, n_key_syms, n_key_actions, total_actions, total_key_behaviors, virtual_mods, total_key_explicit, total_mod_map_keys, total_v_mod_map_keys); - let length_so_far = length_so_far + values_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&values_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetMapRequest { + device_spec, + flags, + min_key_code, + max_key_code, + first_type, + n_types, + first_key_sym, + n_key_syms, + total_syms, + first_key_action, + n_key_actions, + total_actions, + first_key_behavior, + n_key_behaviors, + total_key_behaviors, + first_key_explicit, + n_key_explicit, + total_key_explicit, + first_mod_map_key, + n_mod_map_keys, + total_mod_map_keys, + first_v_mod_map_key, + n_v_mod_map_keys, + total_v_mod_map_keys, + virtual_mods, + values, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetCompatMap request pub const GET_COMPAT_MAP_REQUEST: u8 = 10; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetCompatMapRequest { + pub device_spec: DeviceSpec, + pub groups: u8, + pub get_all_si: bool, + pub first_si: u16, + pub n_si: u16, +} +impl GetCompatMapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let groups_bytes = self.groups.serialize(); + let get_all_si_bytes = self.get_all_si.serialize(); + let first_si_bytes = self.first_si.serialize(); + let n_si_bytes = self.n_si.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_COMPAT_MAP_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + groups_bytes[0], + get_all_si_bytes[0], + first_si_bytes[0], + first_si_bytes[1], + n_si_bytes[0], + n_si_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_compat_map(conn: &Conn, device_spec: DeviceSpec, groups: A, get_all_si: bool, first_si: u16, n_si: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let groups: u8 = groups.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let groups_bytes = groups.serialize(); - let get_all_si_bytes = get_all_si.serialize(); - let first_si_bytes = first_si.serialize(); - let n_si_bytes = n_si.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_COMPAT_MAP_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - groups_bytes[0], - get_all_si_bytes[0], - first_si_bytes[0], - first_si_bytes[1], - n_si_bytes[0], - n_si_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetCompatMapRequest { + device_spec, + groups, + get_all_si, + first_si, + n_si, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -7875,79 +8251,127 @@ impl GetCompatMapReply { /// Opcode for the SetCompatMap request pub const SET_COMPAT_MAP_REQUEST: u8 = 11; -pub fn set_compat_map<'c, Conn, A>(conn: &'c Conn, device_spec: DeviceSpec, recompute_actions: bool, truncate_si: bool, groups: A, first_si: u16, si: &[SymInterpret], group_maps: &[ModDef]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetCompatMapRequest<'input> { + pub device_spec: DeviceSpec, + pub recompute_actions: bool, + pub truncate_si: bool, + pub groups: u8, + pub first_si: u16, + pub si: &'input [SymInterpret], + pub group_maps: &'input [ModDef], +} +impl<'input> SetCompatMapRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let recompute_actions_bytes = self.recompute_actions.serialize(); + let truncate_si_bytes = self.truncate_si.serialize(); + let groups_bytes = self.groups.serialize(); + let first_si_bytes = self.first_si.serialize(); + let n_si = u16::try_from(self.si.len()).expect("`si` has too many elements"); + let n_si_bytes = n_si.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_COMPAT_MAP_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + 0, + recompute_actions_bytes[0], + truncate_si_bytes[0], + groups_bytes[0], + first_si_bytes[0], + first_si_bytes[1], + n_si_bytes[0], + n_si_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let si_bytes = self.si.serialize(); + let length_so_far = length_so_far + si_bytes.len(); + assert_eq!(self.group_maps.len(), usize::try_from(self.groups.count_ones()).unwrap(), "`group_maps` has an incorrect length"); + let group_maps_bytes = self.group_maps.serialize(); + let length_so_far = length_so_far + group_maps_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), si_bytes.into(), group_maps_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_compat_map<'c, 'input, Conn, A>(conn: &'c Conn, device_spec: DeviceSpec, recompute_actions: bool, truncate_si: bool, groups: A, first_si: u16, si: &'input [SymInterpret], group_maps: &'input [ModDef]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let groups: u8 = groups.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let recompute_actions_bytes = recompute_actions.serialize(); - let truncate_si_bytes = truncate_si.serialize(); - let groups_bytes = groups.serialize(); - let first_si_bytes = first_si.serialize(); - let n_si = u16::try_from(si.len()).expect("`si` has too many elements"); - let n_si_bytes = n_si.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_COMPAT_MAP_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - 0, - recompute_actions_bytes[0], - truncate_si_bytes[0], - groups_bytes[0], - first_si_bytes[0], - first_si_bytes[1], - n_si_bytes[0], - n_si_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let si_bytes = si.serialize(); - let length_so_far = length_so_far + si_bytes.len(); - assert_eq!(group_maps.len(), usize::try_from(groups.count_ones()).unwrap(), "`group_maps` has an incorrect length"); - let group_maps_bytes = group_maps.serialize(); - let length_so_far = length_so_far + group_maps_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&si_bytes), IoSlice::new(&group_maps_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetCompatMapRequest { + device_spec, + recompute_actions, + truncate_si, + groups, + first_si, + si, + group_maps, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetIndicatorState request pub const GET_INDICATOR_STATE_REQUEST: u8 = 12; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetIndicatorStateRequest { + pub device_spec: DeviceSpec, +} +impl GetIndicatorStateRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_INDICATOR_STATE_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_indicator_state(conn: &Conn, device_spec: DeviceSpec) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_INDICATOR_STATE_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetIndicatorStateRequest { + device_spec, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -7979,34 +8403,54 @@ impl TryFrom<&[u8]> for GetIndicatorStateReply { /// Opcode for the GetIndicatorMap request pub const GET_INDICATOR_MAP_REQUEST: u8 = 13; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetIndicatorMapRequest { + pub device_spec: DeviceSpec, + pub which: u32, +} +impl GetIndicatorMapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let which_bytes = self.which.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_INDICATOR_MAP_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + 0, + 0, + which_bytes[0], + which_bytes[1], + which_bytes[2], + which_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_indicator_map(conn: &Conn, device_spec: DeviceSpec, which: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let which_bytes = which.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_INDICATOR_MAP_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - 0, - 0, - which_bytes[0], - which_bytes[1], - which_bytes[2], - which_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetIndicatorMapRequest { + device_spec, + which, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -8044,79 +8488,125 @@ impl TryFrom<&[u8]> for GetIndicatorMapReply { /// Opcode for the SetIndicatorMap request pub const SET_INDICATOR_MAP_REQUEST: u8 = 14; -pub fn set_indicator_map<'c, Conn>(conn: &'c Conn, device_spec: DeviceSpec, which: u32, maps: &[IndicatorMap]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetIndicatorMapRequest<'input> { + pub device_spec: DeviceSpec, + pub which: u32, + pub maps: &'input [IndicatorMap], +} +impl<'input> SetIndicatorMapRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let which_bytes = self.which.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_INDICATOR_MAP_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + 0, + 0, + which_bytes[0], + which_bytes[1], + which_bytes[2], + which_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(self.maps.len(), usize::try_from(self.which.count_ones()).unwrap(), "`maps` has an incorrect length"); + let maps_bytes = self.maps.serialize(); + let length_so_far = length_so_far + maps_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), maps_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_indicator_map<'c, 'input, Conn>(conn: &'c Conn, device_spec: DeviceSpec, which: u32, maps: &'input [IndicatorMap]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let which_bytes = which.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_INDICATOR_MAP_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - 0, - 0, - which_bytes[0], - which_bytes[1], - which_bytes[2], - which_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(maps.len(), usize::try_from(which.count_ones()).unwrap(), "`maps` has an incorrect length"); - let maps_bytes = maps.serialize(); - let length_so_far = length_so_far + maps_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&maps_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetIndicatorMapRequest { + device_spec, + which, + maps, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetNamedIndicator request pub const GET_NAMED_INDICATOR_REQUEST: u8 = 15; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetNamedIndicatorRequest { + pub device_spec: DeviceSpec, + pub led_class: LedClass, + pub led_id: IDSpec, + pub indicator: xproto::Atom, +} +impl GetNamedIndicatorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let led_class_bytes = LedClassSpec::from(self.led_class).serialize(); + let led_id_bytes = self.led_id.serialize(); + let indicator_bytes = self.indicator.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_NAMED_INDICATOR_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + led_class_bytes[0], + led_class_bytes[1], + led_id_bytes[0], + led_id_bytes[1], + 0, + 0, + indicator_bytes[0], + indicator_bytes[1], + indicator_bytes[2], + indicator_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_named_indicator(conn: &Conn, device_spec: DeviceSpec, led_class: LedClass, led_id: A, indicator: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let led_id: IDSpec = led_id.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let led_class_bytes = LedClassSpec::from(led_class).serialize(); - let led_id_bytes = led_id.serialize(); - let indicator_bytes = indicator.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_NAMED_INDICATOR_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - led_class_bytes[0], - led_class_bytes[1], - led_id_bytes[0], - led_id_bytes[1], - 0, - 0, - indicator_bytes[0], - indicator_bytes[1], - indicator_bytes[2], - indicator_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetNamedIndicatorRequest { + device_spec, + led_class, + led_id, + indicator, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -8174,6 +8664,89 @@ impl TryFrom<&[u8]> for GetNamedIndicatorReply { /// Opcode for the SetNamedIndicator request pub const SET_NAMED_INDICATOR_REQUEST: u8 = 16; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetNamedIndicatorRequest { + pub device_spec: DeviceSpec, + pub led_class: LedClass, + pub led_id: IDSpec, + pub indicator: xproto::Atom, + pub set_state: bool, + pub on: bool, + pub set_map: bool, + pub create_map: bool, + pub map_flags: u8, + pub map_which_groups: u8, + pub map_groups: u8, + pub map_which_mods: u8, + pub map_real_mods: u8, + pub map_vmods: u16, + pub map_ctrls: u32, +} +impl SetNamedIndicatorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let led_class_bytes = LedClassSpec::from(self.led_class).serialize(); + let led_id_bytes = self.led_id.serialize(); + let indicator_bytes = self.indicator.serialize(); + let set_state_bytes = self.set_state.serialize(); + let on_bytes = self.on.serialize(); + let set_map_bytes = self.set_map.serialize(); + let create_map_bytes = self.create_map.serialize(); + let map_flags_bytes = self.map_flags.serialize(); + let map_which_groups_bytes = self.map_which_groups.serialize(); + let map_groups_bytes = self.map_groups.serialize(); + let map_which_mods_bytes = self.map_which_mods.serialize(); + let map_real_mods_bytes = self.map_real_mods.serialize(); + let map_vmods_bytes = self.map_vmods.serialize(); + let map_ctrls_bytes = self.map_ctrls.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_NAMED_INDICATOR_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + led_class_bytes[0], + led_class_bytes[1], + led_id_bytes[0], + led_id_bytes[1], + 0, + 0, + indicator_bytes[0], + indicator_bytes[1], + indicator_bytes[2], + indicator_bytes[3], + set_state_bytes[0], + on_bytes[0], + set_map_bytes[0], + create_map_bytes[0], + 0, + map_flags_bytes[0], + map_which_groups_bytes[0], + map_groups_bytes[0], + map_which_mods_bytes[0], + map_real_mods_bytes[0], + map_vmods_bytes[0], + map_vmods_bytes[1], + map_ctrls_bytes[0], + map_ctrls_bytes[1], + map_ctrls_bytes[2], + map_ctrls_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_named_indicator(conn: &Conn, device_spec: DeviceSpec, led_class: LedClass, led_id: A, indicator: xproto::Atom, set_state: bool, on: bool, set_map: bool, create_map: bool, map_flags: B, map_which_groups: C, map_groups: D, map_which_mods: E, map_real_mods: F, map_vmods: G, map_ctrls: H) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -8186,8 +8759,6 @@ where G: Into, H: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let led_id: IDSpec = led_id.into(); let map_flags: u8 = map_flags.into(); let map_which_groups: u8 = map_which_groups.into(); @@ -8196,95 +8767,80 @@ where let map_real_mods: u8 = map_real_mods.into(); let map_vmods: u16 = map_vmods.into(); let map_ctrls: u32 = map_ctrls.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let led_class_bytes = LedClassSpec::from(led_class).serialize(); - let led_id_bytes = led_id.serialize(); - let indicator_bytes = indicator.serialize(); - let set_state_bytes = set_state.serialize(); - let on_bytes = on.serialize(); - let set_map_bytes = set_map.serialize(); - let create_map_bytes = create_map.serialize(); - let map_flags_bytes = map_flags.serialize(); - let map_which_groups_bytes = map_which_groups.serialize(); - let map_groups_bytes = map_groups.serialize(); - let map_which_mods_bytes = map_which_mods.serialize(); - let map_real_mods_bytes = map_real_mods.serialize(); - let map_vmods_bytes = map_vmods.serialize(); - let map_ctrls_bytes = map_ctrls.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_NAMED_INDICATOR_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - led_class_bytes[0], - led_class_bytes[1], - led_id_bytes[0], - led_id_bytes[1], - 0, - 0, - indicator_bytes[0], - indicator_bytes[1], - indicator_bytes[2], - indicator_bytes[3], - set_state_bytes[0], - on_bytes[0], - set_map_bytes[0], - create_map_bytes[0], - 0, - map_flags_bytes[0], - map_which_groups_bytes[0], - map_groups_bytes[0], - map_which_mods_bytes[0], - map_real_mods_bytes[0], - map_vmods_bytes[0], - map_vmods_bytes[1], - map_ctrls_bytes[0], - map_ctrls_bytes[1], - map_ctrls_bytes[2], - map_ctrls_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetNamedIndicatorRequest { + device_spec, + led_class, + led_id, + indicator, + set_state, + on, + set_map, + create_map, + map_flags, + map_which_groups, + map_groups, + map_which_mods, + map_real_mods, + map_vmods, + map_ctrls, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetNames request pub const GET_NAMES_REQUEST: u8 = 17; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetNamesRequest { + pub device_spec: DeviceSpec, + pub which: u32, +} +impl GetNamesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let which_bytes = self.which.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_NAMES_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + 0, + 0, + which_bytes[0], + which_bytes[1], + which_bytes[2], + which_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_names(conn: &Conn, device_spec: DeviceSpec, which: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let which: u32 = which.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let which_bytes = which.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_NAMES_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - 0, - 0, - which_bytes[0], - which_bytes[1], - which_bytes[2], - which_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetNamesRequest { + device_spec, + which, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -8494,8 +9050,6 @@ impl TryFrom<&[u8]> for GetNamesReply { } } -/// Opcode for the SetNames request -pub const SET_NAMES_REQUEST: u8 = 18; #[derive(Debug, Clone, PartialEq, Eq)] pub struct SetNamesAuxBitcase8 { pub n_levels_per_type: Vec, @@ -8718,75 +9272,182 @@ impl SetNamesAux { } } -pub fn set_names<'c, Conn, A, B>(conn: &'c Conn, device_spec: DeviceSpec, virtual_mods: A, first_type: u8, n_types: u8, first_kt_levelt: u8, n_kt_levels: u8, indicators: u32, group_names: B, n_radio_groups: u8, first_key: xproto::Keycode, n_keys: u8, n_key_aliases: u8, total_kt_level_names: u16, values: &SetNamesAux) -> Result, ConnectionError> +/// Opcode for the SetNames request +pub const SET_NAMES_REQUEST: u8 = 18; +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetNamesRequest<'input> { + pub device_spec: DeviceSpec, + pub virtual_mods: u16, + pub first_type: u8, + pub n_types: u8, + pub first_kt_levelt: u8, + pub n_kt_levels: u8, + pub indicators: u32, + pub group_names: u8, + pub n_radio_groups: u8, + pub first_key: xproto::Keycode, + pub n_keys: u8, + pub n_key_aliases: u8, + pub total_kt_level_names: u16, + pub values: &'input SetNamesAux, +} +impl<'input> SetNamesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let virtual_mods_bytes = self.virtual_mods.serialize(); + let which = u32::try_from(self.values.switch_expr()).unwrap(); + let which_bytes = which.serialize(); + let first_type_bytes = self.first_type.serialize(); + let n_types_bytes = self.n_types.serialize(); + let first_kt_levelt_bytes = self.first_kt_levelt.serialize(); + let n_kt_levels_bytes = self.n_kt_levels.serialize(); + let indicators_bytes = self.indicators.serialize(); + let group_names_bytes = self.group_names.serialize(); + let n_radio_groups_bytes = self.n_radio_groups.serialize(); + let first_key_bytes = self.first_key.serialize(); + let n_keys_bytes = self.n_keys.serialize(); + let n_key_aliases_bytes = self.n_key_aliases.serialize(); + let total_kt_level_names_bytes = self.total_kt_level_names.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_NAMES_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + virtual_mods_bytes[0], + virtual_mods_bytes[1], + which_bytes[0], + which_bytes[1], + which_bytes[2], + which_bytes[3], + first_type_bytes[0], + n_types_bytes[0], + first_kt_levelt_bytes[0], + n_kt_levels_bytes[0], + indicators_bytes[0], + indicators_bytes[1], + indicators_bytes[2], + indicators_bytes[3], + group_names_bytes[0], + n_radio_groups_bytes[0], + first_key_bytes[0], + n_keys_bytes[0], + n_key_aliases_bytes[0], + 0, + total_kt_level_names_bytes[0], + total_kt_level_names_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let values_bytes = self.values.serialize(which, self.n_types, self.indicators, self.virtual_mods, self.group_names, self.n_keys, self.n_key_aliases, self.n_radio_groups); + let length_so_far = length_so_far + values_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), values_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_names<'c, 'input, Conn, A, B>(conn: &'c Conn, device_spec: DeviceSpec, virtual_mods: A, first_type: u8, n_types: u8, first_kt_levelt: u8, n_kt_levels: u8, indicators: u32, group_names: B, n_radio_groups: u8, first_key: xproto::Keycode, n_keys: u8, n_key_aliases: u8, total_kt_level_names: u16, values: &'input SetNamesAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let virtual_mods: u16 = virtual_mods.into(); let group_names: u8 = group_names.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let virtual_mods_bytes = virtual_mods.serialize(); - let which = u32::try_from(values.switch_expr()).unwrap(); - let which_bytes = which.serialize(); - let first_type_bytes = first_type.serialize(); - let n_types_bytes = n_types.serialize(); - let first_kt_levelt_bytes = first_kt_levelt.serialize(); - let n_kt_levels_bytes = n_kt_levels.serialize(); - let indicators_bytes = indicators.serialize(); - let group_names_bytes = group_names.serialize(); - let n_radio_groups_bytes = n_radio_groups.serialize(); - let first_key_bytes = first_key.serialize(); - let n_keys_bytes = n_keys.serialize(); - let n_key_aliases_bytes = n_key_aliases.serialize(); - let total_kt_level_names_bytes = total_kt_level_names.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_NAMES_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - virtual_mods_bytes[0], - virtual_mods_bytes[1], - which_bytes[0], - which_bytes[1], - which_bytes[2], - which_bytes[3], - first_type_bytes[0], - n_types_bytes[0], - first_kt_levelt_bytes[0], - n_kt_levels_bytes[0], - indicators_bytes[0], - indicators_bytes[1], - indicators_bytes[2], - indicators_bytes[3], - group_names_bytes[0], - n_radio_groups_bytes[0], - first_key_bytes[0], - n_keys_bytes[0], - n_key_aliases_bytes[0], - 0, - total_kt_level_names_bytes[0], - total_kt_level_names_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let values_bytes = values.serialize(which, n_types, indicators, virtual_mods, group_names, n_keys, n_key_aliases, n_radio_groups); - let length_so_far = length_so_far + values_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&values_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetNamesRequest { + device_spec, + virtual_mods, + first_type, + n_types, + first_kt_levelt, + n_kt_levels, + indicators, + group_names, + n_radio_groups, + first_key, + n_keys, + n_key_aliases, + total_kt_level_names, + values, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PerClientFlags request pub const PER_CLIENT_FLAGS_REQUEST: u8 = 21; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PerClientFlagsRequest { + pub device_spec: DeviceSpec, + pub change: u32, + pub value: u32, + pub ctrls_to_change: u32, + pub auto_ctrls: u32, + pub auto_ctrls_values: u32, +} +impl PerClientFlagsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let change_bytes = self.change.serialize(); + let value_bytes = self.value.serialize(); + let ctrls_to_change_bytes = self.ctrls_to_change.serialize(); + let auto_ctrls_bytes = self.auto_ctrls.serialize(); + let auto_ctrls_values_bytes = self.auto_ctrls_values.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PER_CLIENT_FLAGS_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + 0, + 0, + change_bytes[0], + change_bytes[1], + change_bytes[2], + change_bytes[3], + value_bytes[0], + value_bytes[1], + value_bytes[2], + value_bytes[3], + ctrls_to_change_bytes[0], + ctrls_to_change_bytes[1], + ctrls_to_change_bytes[2], + ctrls_to_change_bytes[3], + auto_ctrls_bytes[0], + auto_ctrls_bytes[1], + auto_ctrls_bytes[2], + auto_ctrls_bytes[3], + auto_ctrls_values_bytes[0], + auto_ctrls_values_bytes[1], + auto_ctrls_values_bytes[2], + auto_ctrls_values_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn per_client_flags(conn: &Conn, device_spec: DeviceSpec, change: A, value: B, ctrls_to_change: C, auto_ctrls: D, auto_ctrls_values: E) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -8796,55 +9457,22 @@ where D: Into, E: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let change: u32 = change.into(); let value: u32 = value.into(); let ctrls_to_change: u32 = ctrls_to_change.into(); let auto_ctrls: u32 = auto_ctrls.into(); let auto_ctrls_values: u32 = auto_ctrls_values.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let change_bytes = change.serialize(); - let value_bytes = value.serialize(); - let ctrls_to_change_bytes = ctrls_to_change.serialize(); - let auto_ctrls_bytes = auto_ctrls.serialize(); - let auto_ctrls_values_bytes = auto_ctrls_values.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PER_CLIENT_FLAGS_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - 0, - 0, - change_bytes[0], - change_bytes[1], - change_bytes[2], - change_bytes[3], - value_bytes[0], - value_bytes[1], - value_bytes[2], - value_bytes[3], - ctrls_to_change_bytes[0], - ctrls_to_change_bytes[1], - ctrls_to_change_bytes[2], - ctrls_to_change_bytes[3], - auto_ctrls_bytes[0], - auto_ctrls_bytes[1], - auto_ctrls_bytes[2], - auto_ctrls_bytes[3], - auto_ctrls_values_bytes[0], - auto_ctrls_values_bytes[1], - auto_ctrls_values_bytes[2], - auto_ctrls_values_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PerClientFlagsRequest { + device_spec, + change, + value, + ctrls_to_change, + auto_ctrls, + auto_ctrls_values, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -8882,30 +9510,50 @@ impl TryFrom<&[u8]> for PerClientFlagsReply { /// Opcode for the ListComponents request pub const LIST_COMPONENTS_REQUEST: u8 = 22; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListComponentsRequest { + pub device_spec: DeviceSpec, + pub max_names: u16, +} +impl ListComponentsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let max_names_bytes = self.max_names.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + LIST_COMPONENTS_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + max_names_bytes[0], + max_names_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_components(conn: &Conn, device_spec: DeviceSpec, max_names: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let max_names_bytes = max_names.serialize(); - let mut request0 = [ - extension_information.major_opcode, - LIST_COMPONENTS_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - max_names_bytes[0], - max_names_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListComponentsRequest { + device_spec, + max_names, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -9035,40 +9683,64 @@ impl ListComponentsReply { /// Opcode for the GetKbdByName request pub const GET_KBD_BY_NAME_REQUEST: u8 = 23; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetKbdByNameRequest { + pub device_spec: DeviceSpec, + pub need: u16, + pub want: u16, + pub load: bool, +} +impl GetKbdByNameRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let need_bytes = self.need.serialize(); + let want_bytes = self.want.serialize(); + let load_bytes = self.load.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_KBD_BY_NAME_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + need_bytes[0], + need_bytes[1], + want_bytes[0], + want_bytes[1], + load_bytes[0], + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_kbd_by_name(conn: &Conn, device_spec: DeviceSpec, need: A, want: B, load: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let need: u16 = need.into(); let want: u16 = want.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let need_bytes = need.serialize(); - let want_bytes = want.serialize(); - let load_bytes = load.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_KBD_BY_NAME_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - need_bytes[0], - need_bytes[1], - want_bytes[0], - want_bytes[1], - load_bytes[0], - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetKbdByNameRequest { + device_spec, + need, + want, + load, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone)] @@ -9712,47 +10384,77 @@ impl TryFrom<&[u8]> for GetKbdByNameReply { /// Opcode for the GetDeviceInfo request pub const GET_DEVICE_INFO_REQUEST: u8 = 24; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceInfoRequest { + pub device_spec: DeviceSpec, + pub wanted: u16, + pub all_buttons: bool, + pub first_button: u8, + pub n_buttons: u8, + pub led_class: LedClass, + pub led_id: IDSpec, +} +impl GetDeviceInfoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let wanted_bytes = self.wanted.serialize(); + let all_buttons_bytes = self.all_buttons.serialize(); + let first_button_bytes = self.first_button.serialize(); + let n_buttons_bytes = self.n_buttons.serialize(); + let led_class_bytes = LedClassSpec::from(self.led_class).serialize(); + let led_id_bytes = self.led_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_INFO_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + wanted_bytes[0], + wanted_bytes[1], + all_buttons_bytes[0], + first_button_bytes[0], + n_buttons_bytes[0], + 0, + led_class_bytes[0], + led_class_bytes[1], + led_id_bytes[0], + led_id_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_info(conn: &Conn, device_spec: DeviceSpec, wanted: A, all_buttons: bool, first_button: u8, n_buttons: u8, led_class: LedClass, led_id: B) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, B: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let wanted: u16 = wanted.into(); let led_id: IDSpec = led_id.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let wanted_bytes = wanted.serialize(); - let all_buttons_bytes = all_buttons.serialize(); - let first_button_bytes = first_button.serialize(); - let n_buttons_bytes = n_buttons.serialize(); - let led_class_bytes = LedClassSpec::from(led_class).serialize(); - let led_id_bytes = led_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_INFO_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - wanted_bytes[0], - wanted_bytes[1], - all_buttons_bytes[0], - first_button_bytes[0], - n_buttons_bytes[0], - 0, - led_class_bytes[0], - led_class_bytes[1], - led_id_bytes[0], - led_id_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceInfoRequest { + device_spec, + wanted, + all_buttons, + first_button, + n_buttons, + led_class, + led_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone)] @@ -9860,98 +10562,150 @@ impl GetDeviceInfoReply { /// Opcode for the SetDeviceInfo request pub const SET_DEVICE_INFO_REQUEST: u8 = 25; -pub fn set_device_info<'c, Conn, A>(conn: &'c Conn, device_spec: DeviceSpec, first_btn: u8, change: A, btn_actions: &[Action], leds: &[DeviceLedInfo]) -> Result, ConnectionError> +#[derive(Debug, Clone)] +pub struct SetDeviceInfoRequest<'input> { + pub device_spec: DeviceSpec, + pub first_btn: u8, + pub change: u16, + pub btn_actions: &'input [Action], + pub leds: &'input [DeviceLedInfo], +} +impl<'input> SetDeviceInfoRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_spec_bytes = self.device_spec.serialize(); + let first_btn_bytes = self.first_btn.serialize(); + let n_btns = u8::try_from(self.btn_actions.len()).expect("`btn_actions` has too many elements"); + let n_btns_bytes = n_btns.serialize(); + let change_bytes = self.change.serialize(); + let n_device_led_f_bs = u16::try_from(self.leds.len()).expect("`leds` has too many elements"); + let n_device_led_f_bs_bytes = n_device_led_f_bs.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_DEVICE_INFO_REQUEST, + 0, + 0, + device_spec_bytes[0], + device_spec_bytes[1], + first_btn_bytes[0], + n_btns_bytes[0], + change_bytes[0], + change_bytes[1], + n_device_led_f_bs_bytes[0], + n_device_led_f_bs_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let btn_actions_bytes = self.btn_actions.serialize(); + let length_so_far = length_so_far + btn_actions_bytes.len(); + let leds_bytes = self.leds.serialize(); + let length_so_far = length_so_far + leds_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), btn_actions_bytes.into(), leds_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_device_info<'c, 'input, Conn, A>(conn: &'c Conn, device_spec: DeviceSpec, first_btn: u8, change: A, btn_actions: &'input [Action], leds: &'input [DeviceLedInfo]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let change: u16 = change.into(); - let length_so_far = 0; - let device_spec_bytes = device_spec.serialize(); - let first_btn_bytes = first_btn.serialize(); - let n_btns = u8::try_from(btn_actions.len()).expect("`btn_actions` has too many elements"); - let n_btns_bytes = n_btns.serialize(); - let change_bytes = change.serialize(); - let n_device_led_f_bs = u16::try_from(leds.len()).expect("`leds` has too many elements"); - let n_device_led_f_bs_bytes = n_device_led_f_bs.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_DEVICE_INFO_REQUEST, - 0, - 0, - device_spec_bytes[0], - device_spec_bytes[1], - first_btn_bytes[0], - n_btns_bytes[0], - change_bytes[0], - change_bytes[1], - n_device_led_f_bs_bytes[0], - n_device_led_f_bs_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let btn_actions_bytes = btn_actions.serialize(); - let length_so_far = length_so_far + btn_actions_bytes.len(); - let leds_bytes = leds.serialize(); - let length_so_far = length_so_far + leds_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&btn_actions_bytes), IoSlice::new(&leds_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetDeviceInfoRequest { + device_spec, + first_btn, + change, + btn_actions, + leds, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetDebuggingFlags request pub const SET_DEBUGGING_FLAGS_REQUEST: u8 = 101; -pub fn set_debugging_flags<'c, Conn>(conn: &'c Conn, affect_flags: u32, flags: u32, affect_ctrls: u32, ctrls: u32, message: &[String8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetDebuggingFlagsRequest<'input> { + pub affect_flags: u32, + pub flags: u32, + pub affect_ctrls: u32, + pub ctrls: u32, + pub message: &'input [String8], +} +impl<'input> SetDebuggingFlagsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let msg_length = u16::try_from(self.message.len()).expect("`message` has too many elements"); + let msg_length_bytes = msg_length.serialize(); + let affect_flags_bytes = self.affect_flags.serialize(); + let flags_bytes = self.flags.serialize(); + let affect_ctrls_bytes = self.affect_ctrls.serialize(); + let ctrls_bytes = self.ctrls.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_DEBUGGING_FLAGS_REQUEST, + 0, + 0, + msg_length_bytes[0], + msg_length_bytes[1], + 0, + 0, + affect_flags_bytes[0], + affect_flags_bytes[1], + affect_flags_bytes[2], + affect_flags_bytes[3], + flags_bytes[0], + flags_bytes[1], + flags_bytes[2], + flags_bytes[3], + affect_ctrls_bytes[0], + affect_ctrls_bytes[1], + affect_ctrls_bytes[2], + affect_ctrls_bytes[3], + ctrls_bytes[0], + ctrls_bytes[1], + ctrls_bytes[2], + ctrls_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.message[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.message[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_debugging_flags<'c, 'input, Conn>(conn: &'c Conn, affect_flags: u32, flags: u32, affect_ctrls: u32, ctrls: u32, message: &'input [String8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let msg_length = u16::try_from(message.len()).expect("`message` has too many elements"); - let msg_length_bytes = msg_length.serialize(); - let affect_flags_bytes = affect_flags.serialize(); - let flags_bytes = flags.serialize(); - let affect_ctrls_bytes = affect_ctrls.serialize(); - let ctrls_bytes = ctrls.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_DEBUGGING_FLAGS_REQUEST, - 0, - 0, - msg_length_bytes[0], - msg_length_bytes[1], - 0, - 0, - affect_flags_bytes[0], - affect_flags_bytes[1], - affect_flags_bytes[2], - affect_flags_bytes[3], - flags_bytes[0], - flags_bytes[1], - flags_bytes[2], - flags_bytes[3], - affect_ctrls_bytes[0], - affect_ctrls_bytes[1], - affect_ctrls_bytes[2], - affect_ctrls_bytes[3], - ctrls_bytes[0], - ctrls_bytes[1], - ctrls_bytes[2], - ctrls_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + message.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(message), IoSlice::new(&padding0)], vec![])?) + let request0 = SetDebuggingFlagsRequest { + affect_flags, + flags, + affect_ctrls, + ctrls, + message, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -11229,7 +11983,7 @@ pub trait ConnectionExt: RequestConnection { { use_extension(self, wanted_major, wanted_minor) } - fn xkb_select_events<'c, A, B, C, D, E>(&'c self, device_spec: DeviceSpec, affect_which: A, clear: B, select_all: C, affect_map: D, map: E, details: &SelectEventsAux) -> Result, ConnectionError> + fn xkb_select_events<'c, 'input, A, B, C, D, E>(&'c self, device_spec: DeviceSpec, affect_which: A, clear: B, select_all: C, affect_map: D, map: E, details: &'input SelectEventsAux) -> Result, ConnectionError> where A: Into, B: Into, @@ -11259,7 +12013,7 @@ pub trait ConnectionExt: RequestConnection { { get_controls(self, device_spec) } - fn xkb_set_controls<'c, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(&'c self, device_spec: DeviceSpec, affect_internal_real_mods: A, internal_real_mods: B, affect_ignore_lock_real_mods: C, ignore_lock_real_mods: D, affect_internal_virtual_mods: E, internal_virtual_mods: F, affect_ignore_lock_virtual_mods: G, ignore_lock_virtual_mods: H, mouse_keys_dflt_btn: u8, groups_wrap: u8, access_x_options: I, affect_enabled_controls: J, enabled_controls: K, change_controls: L, repeat_delay: u16, repeat_interval: u16, slow_keys_delay: u16, debounce_delay: u16, mouse_keys_delay: u16, mouse_keys_interval: u16, mouse_keys_time_to_max: u16, mouse_keys_max_speed: u16, mouse_keys_curve: i16, access_x_timeout: u16, access_x_timeout_mask: M, access_x_timeout_values: N, access_x_timeout_options_mask: O, access_x_timeout_options_values: P, per_key_repeat: &[u8; 32]) -> Result, ConnectionError> + fn xkb_set_controls<'c, 'input, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(&'c self, device_spec: DeviceSpec, affect_internal_real_mods: A, internal_real_mods: B, affect_ignore_lock_real_mods: C, ignore_lock_real_mods: D, affect_internal_virtual_mods: E, internal_virtual_mods: F, affect_ignore_lock_virtual_mods: G, ignore_lock_virtual_mods: H, mouse_keys_dflt_btn: u8, groups_wrap: u8, access_x_options: I, affect_enabled_controls: J, enabled_controls: K, change_controls: L, repeat_delay: u16, repeat_interval: u16, slow_keys_delay: u16, debounce_delay: u16, mouse_keys_delay: u16, mouse_keys_interval: u16, mouse_keys_time_to_max: u16, mouse_keys_max_speed: u16, mouse_keys_curve: i16, access_x_timeout: u16, access_x_timeout_mask: M, access_x_timeout_values: N, access_x_timeout_options_mask: O, access_x_timeout_options_values: P, per_key_repeat: &'input [u8; 32]) -> Result, ConnectionError> where A: Into, B: Into, @@ -11288,7 +12042,7 @@ pub trait ConnectionExt: RequestConnection { { get_map(self, device_spec, full, partial, first_type, n_types, first_key_sym, n_key_syms, first_key_action, n_key_actions, first_key_behavior, n_key_behaviors, virtual_mods, first_key_explicit, n_key_explicit, first_mod_map_key, n_mod_map_keys, first_v_mod_map_key, n_v_mod_map_keys) } - fn xkb_set_map<'c, A, B>(&'c self, device_spec: DeviceSpec, flags: A, min_key_code: xproto::Keycode, max_key_code: xproto::Keycode, first_type: u8, n_types: u8, first_key_sym: xproto::Keycode, n_key_syms: u8, total_syms: u16, first_key_action: xproto::Keycode, n_key_actions: u8, total_actions: u16, first_key_behavior: xproto::Keycode, n_key_behaviors: u8, total_key_behaviors: u8, first_key_explicit: xproto::Keycode, n_key_explicit: u8, total_key_explicit: u8, first_mod_map_key: xproto::Keycode, n_mod_map_keys: u8, total_mod_map_keys: u8, first_v_mod_map_key: xproto::Keycode, n_v_mod_map_keys: u8, total_v_mod_map_keys: u8, virtual_mods: B, values: &SetMapAux) -> Result, ConnectionError> + fn xkb_set_map<'c, 'input, A, B>(&'c self, device_spec: DeviceSpec, flags: A, min_key_code: xproto::Keycode, max_key_code: xproto::Keycode, first_type: u8, n_types: u8, first_key_sym: xproto::Keycode, n_key_syms: u8, total_syms: u16, first_key_action: xproto::Keycode, n_key_actions: u8, total_actions: u16, first_key_behavior: xproto::Keycode, n_key_behaviors: u8, total_key_behaviors: u8, first_key_explicit: xproto::Keycode, n_key_explicit: u8, total_key_explicit: u8, first_mod_map_key: xproto::Keycode, n_mod_map_keys: u8, total_mod_map_keys: u8, first_v_mod_map_key: xproto::Keycode, n_v_mod_map_keys: u8, total_v_mod_map_keys: u8, virtual_mods: B, values: &'input SetMapAux) -> Result, ConnectionError> where A: Into, B: Into, @@ -11301,7 +12055,7 @@ pub trait ConnectionExt: RequestConnection { { get_compat_map(self, device_spec, groups, get_all_si, first_si, n_si) } - fn xkb_set_compat_map<'c, A>(&'c self, device_spec: DeviceSpec, recompute_actions: bool, truncate_si: bool, groups: A, first_si: u16, si: &[SymInterpret], group_maps: &[ModDef]) -> Result, ConnectionError> + fn xkb_set_compat_map<'c, 'input, A>(&'c self, device_spec: DeviceSpec, recompute_actions: bool, truncate_si: bool, groups: A, first_si: u16, si: &'input [SymInterpret], group_maps: &'input [ModDef]) -> Result, ConnectionError> where A: Into, { @@ -11315,7 +12069,7 @@ pub trait ConnectionExt: RequestConnection { { get_indicator_map(self, device_spec, which) } - fn xkb_set_indicator_map<'c>(&'c self, device_spec: DeviceSpec, which: u32, maps: &[IndicatorMap]) -> Result, ConnectionError> + fn xkb_set_indicator_map<'c, 'input>(&'c self, device_spec: DeviceSpec, which: u32, maps: &'input [IndicatorMap]) -> Result, ConnectionError> { set_indicator_map(self, device_spec, which, maps) } @@ -11344,7 +12098,7 @@ pub trait ConnectionExt: RequestConnection { { get_names(self, device_spec, which) } - fn xkb_set_names<'c, A, B>(&'c self, device_spec: DeviceSpec, virtual_mods: A, first_type: u8, n_types: u8, first_kt_levelt: u8, n_kt_levels: u8, indicators: u32, group_names: B, n_radio_groups: u8, first_key: xproto::Keycode, n_keys: u8, n_key_aliases: u8, total_kt_level_names: u16, values: &SetNamesAux) -> Result, ConnectionError> + fn xkb_set_names<'c, 'input, A, B>(&'c self, device_spec: DeviceSpec, virtual_mods: A, first_type: u8, n_types: u8, first_kt_levelt: u8, n_kt_levels: u8, indicators: u32, group_names: B, n_radio_groups: u8, first_key: xproto::Keycode, n_keys: u8, n_key_aliases: u8, total_kt_level_names: u16, values: &'input SetNamesAux) -> Result, ConnectionError> where A: Into, B: Into, @@ -11379,13 +12133,13 @@ pub trait ConnectionExt: RequestConnection { { get_device_info(self, device_spec, wanted, all_buttons, first_button, n_buttons, led_class, led_id) } - fn xkb_set_device_info<'c, A>(&'c self, device_spec: DeviceSpec, first_btn: u8, change: A, btn_actions: &[Action], leds: &[DeviceLedInfo]) -> Result, ConnectionError> + fn xkb_set_device_info<'c, 'input, A>(&'c self, device_spec: DeviceSpec, first_btn: u8, change: A, btn_actions: &'input [Action], leds: &'input [DeviceLedInfo]) -> Result, ConnectionError> where A: Into, { set_device_info(self, device_spec, first_btn, change, btn_actions, leds) } - fn xkb_set_debugging_flags<'c>(&'c self, affect_flags: u32, flags: u32, affect_ctrls: u32, ctrls: u32, message: &[String8]) -> Result, ConnectionError> + fn xkb_set_debugging_flags<'c, 'input>(&'c self, affect_flags: u32, flags: u32, affect_ctrls: u32, ctrls: u32, message: &'input [String8]) -> Result, ConnectionError> { set_debugging_flags(self, affect_flags, flags, affect_ctrls, ctrls, message) } diff --git a/src/protocol/xprint.rs b/src/protocol/xprint.rs index ba571d9a..d1fb1918 100644 --- a/src/protocol/xprint.rs +++ b/src/protocol/xprint.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -405,24 +405,38 @@ impl TryFrom for Attr { /// Opcode for the PrintQueryVersion request pub const PRINT_QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintQueryVersionRequest; +impl PrintQueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_QUERY_VERSION_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_query_version(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - PRINT_QUERY_VERSION_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintQueryVersionRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -454,40 +468,60 @@ impl TryFrom<&[u8]> for PrintQueryVersionReply { /// Opcode for the PrintGetPrinterList request pub const PRINT_GET_PRINTER_LIST_REQUEST: u8 = 1; -pub fn print_get_printer_list<'c, Conn>(conn: &'c Conn, printer_name: &[String8], locale: &[String8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PrintGetPrinterListRequest<'input> { + pub printer_name: &'input [String8], + pub locale: &'input [String8], +} +impl<'input> PrintGetPrinterListRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let printer_name_len = u32::try_from(self.printer_name.len()).expect("`printer_name` has too many elements"); + let printer_name_len_bytes = printer_name_len.serialize(); + let locale_len = u32::try_from(self.locale.len()).expect("`locale` has too many elements"); + let locale_len_bytes = locale_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_GET_PRINTER_LIST_REQUEST, + 0, + 0, + printer_name_len_bytes[0], + printer_name_len_bytes[1], + printer_name_len_bytes[2], + printer_name_len_bytes[3], + locale_len_bytes[0], + locale_len_bytes[1], + locale_len_bytes[2], + locale_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.printer_name[..]).len(); + let length_so_far = length_so_far + (&self.locale[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.printer_name[..]).into(), (&self.locale[..]).into(), padding0.into()], vec![])) + } +} +pub fn print_get_printer_list<'c, 'input, Conn>(conn: &'c Conn, printer_name: &'input [String8], locale: &'input [String8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let printer_name_len = u32::try_from(printer_name.len()).expect("`printer_name` has too many elements"); - let printer_name_len_bytes = printer_name_len.serialize(); - let locale_len = u32::try_from(locale.len()).expect("`locale` has too many elements"); - let locale_len_bytes = locale_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_GET_PRINTER_LIST_REQUEST, - 0, - 0, - printer_name_len_bytes[0], - printer_name_len_bytes[1], - printer_name_len_bytes[2], - printer_name_len_bytes[3], - locale_len_bytes[0], - locale_len_bytes[1], - locale_len_bytes[2], - locale_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + printer_name.len(); - let length_so_far = length_so_far + locale.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(printer_name), IoSlice::new(locale), IoSlice::new(&padding0)], vec![])?) + let request0 = PrintGetPrinterListRequest { + printer_name, + locale, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -534,116 +568,184 @@ impl PrintGetPrinterListReply { /// Opcode for the PrintRehashPrinterList request pub const PRINT_REHASH_PRINTER_LIST_REQUEST: u8 = 20; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintRehashPrinterListRequest; +impl PrintRehashPrinterListRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_REHASH_PRINTER_LIST_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_rehash_printer_list(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - PRINT_REHASH_PRINTER_LIST_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintRehashPrinterListRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateContext request pub const CREATE_CONTEXT_REQUEST: u8 = 2; -pub fn create_context<'c, Conn>(conn: &'c Conn, context_id: u32, printer_name: &[String8], locale: &[String8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreateContextRequest<'input> { + pub context_id: u32, + pub printer_name: &'input [String8], + pub locale: &'input [String8], +} +impl<'input> CreateContextRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_id_bytes = self.context_id.serialize(); + let printer_name_len = u32::try_from(self.printer_name.len()).expect("`printer_name` has too many elements"); + let printer_name_len_bytes = printer_name_len.serialize(); + let locale_len = u32::try_from(self.locale.len()).expect("`locale` has too many elements"); + let locale_len_bytes = locale_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_CONTEXT_REQUEST, + 0, + 0, + context_id_bytes[0], + context_id_bytes[1], + context_id_bytes[2], + context_id_bytes[3], + printer_name_len_bytes[0], + printer_name_len_bytes[1], + printer_name_len_bytes[2], + printer_name_len_bytes[3], + locale_len_bytes[0], + locale_len_bytes[1], + locale_len_bytes[2], + locale_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.printer_name[..]).len(); + let length_so_far = length_so_far + (&self.locale[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.printer_name[..]).into(), (&self.locale[..]).into(), padding0.into()], vec![])) + } +} +pub fn create_context<'c, 'input, Conn>(conn: &'c Conn, context_id: u32, printer_name: &'input [String8], locale: &'input [String8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_id_bytes = context_id.serialize(); - let printer_name_len = u32::try_from(printer_name.len()).expect("`printer_name` has too many elements"); - let printer_name_len_bytes = printer_name_len.serialize(); - let locale_len = u32::try_from(locale.len()).expect("`locale` has too many elements"); - let locale_len_bytes = locale_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_CONTEXT_REQUEST, - 0, - 0, - context_id_bytes[0], - context_id_bytes[1], - context_id_bytes[2], - context_id_bytes[3], - printer_name_len_bytes[0], - printer_name_len_bytes[1], - printer_name_len_bytes[2], - printer_name_len_bytes[3], - locale_len_bytes[0], - locale_len_bytes[1], - locale_len_bytes[2], - locale_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + printer_name.len(); - let length_so_far = length_so_far + locale.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(printer_name), IoSlice::new(locale), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateContextRequest { + context_id, + printer_name, + locale, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintSetContext request pub const PRINT_SET_CONTEXT_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintSetContextRequest { + pub context: u32, +} +impl PrintSetContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_SET_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_set_context(conn: &Conn, context: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_SET_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintSetContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintGetContext request pub const PRINT_GET_CONTEXT_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintGetContextRequest; +impl PrintGetContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_GET_CONTEXT_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_get_context(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - PRINT_GET_CONTEXT_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintGetContextRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -673,51 +775,83 @@ impl TryFrom<&[u8]> for PrintGetContextReply { /// Opcode for the PrintDestroyContext request pub const PRINT_DESTROY_CONTEXT_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintDestroyContextRequest { + pub context: u32, +} +impl PrintDestroyContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_DESTROY_CONTEXT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_destroy_context(conn: &Conn, context: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_DESTROY_CONTEXT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintDestroyContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintGetScreenOfContext request pub const PRINT_GET_SCREEN_OF_CONTEXT_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintGetScreenOfContextRequest; +impl PrintGetScreenOfContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_GET_SCREEN_OF_CONTEXT_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_get_screen_of_context(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - PRINT_GET_SCREEN_OF_CONTEXT_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintGetScreenOfContextRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -747,188 +881,304 @@ impl TryFrom<&[u8]> for PrintGetScreenOfContextReply { /// Opcode for the PrintStartJob request pub const PRINT_START_JOB_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintStartJobRequest { + pub output_mode: u8, +} +impl PrintStartJobRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let output_mode_bytes = self.output_mode.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_START_JOB_REQUEST, + 0, + 0, + output_mode_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_start_job(conn: &Conn, output_mode: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let output_mode_bytes = output_mode.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_START_JOB_REQUEST, - 0, - 0, - output_mode_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintStartJobRequest { + output_mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintEndJob request pub const PRINT_END_JOB_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintEndJobRequest { + pub cancel: bool, +} +impl PrintEndJobRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let cancel_bytes = self.cancel.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_END_JOB_REQUEST, + 0, + 0, + cancel_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_end_job(conn: &Conn, cancel: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let cancel_bytes = cancel.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_END_JOB_REQUEST, - 0, - 0, - cancel_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintEndJobRequest { + cancel, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintStartDoc request pub const PRINT_START_DOC_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintStartDocRequest { + pub driver_mode: u8, +} +impl PrintStartDocRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let driver_mode_bytes = self.driver_mode.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_START_DOC_REQUEST, + 0, + 0, + driver_mode_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_start_doc(conn: &Conn, driver_mode: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let driver_mode_bytes = driver_mode.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_START_DOC_REQUEST, - 0, - 0, - driver_mode_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintStartDocRequest { + driver_mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintEndDoc request pub const PRINT_END_DOC_REQUEST: u8 = 10; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintEndDocRequest { + pub cancel: bool, +} +impl PrintEndDocRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let cancel_bytes = self.cancel.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_END_DOC_REQUEST, + 0, + 0, + cancel_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_end_doc(conn: &Conn, cancel: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let cancel_bytes = cancel.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_END_DOC_REQUEST, - 0, - 0, - cancel_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintEndDocRequest { + cancel, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintPutDocumentData request pub const PRINT_PUT_DOCUMENT_DATA_REQUEST: u8 = 11; -pub fn print_put_document_data<'c, Conn>(conn: &'c Conn, drawable: xproto::Drawable, data: &[u8], doc_format: &[String8], options: &[String8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PrintPutDocumentDataRequest<'input> { + pub drawable: xproto::Drawable, + pub data: &'input [u8], + pub doc_format: &'input [String8], + pub options: &'input [String8], +} +impl<'input> PrintPutDocumentDataRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let len_data = u32::try_from(self.data.len()).expect("`data` has too many elements"); + let len_data_bytes = len_data.serialize(); + let len_fmt = u16::try_from(self.doc_format.len()).expect("`doc_format` has too many elements"); + let len_fmt_bytes = len_fmt.serialize(); + let len_options = u16::try_from(self.options.len()).expect("`options` has too many elements"); + let len_options_bytes = len_options.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_PUT_DOCUMENT_DATA_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + len_data_bytes[0], + len_data_bytes[1], + len_data_bytes[2], + len_data_bytes[3], + len_fmt_bytes[0], + len_fmt_bytes[1], + len_options_bytes[0], + len_options_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.data[..]).len(); + let length_so_far = length_so_far + (&self.doc_format[..]).len(); + let length_so_far = length_so_far + (&self.options[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.data[..]).into(), (&self.doc_format[..]).into(), (&self.options[..]).into(), padding0.into()], vec![])) + } +} +pub fn print_put_document_data<'c, 'input, Conn>(conn: &'c Conn, drawable: xproto::Drawable, data: &'input [u8], doc_format: &'input [String8], options: &'input [String8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let len_data = u32::try_from(data.len()).expect("`data` has too many elements"); - let len_data_bytes = len_data.serialize(); - let len_fmt = u16::try_from(doc_format.len()).expect("`doc_format` has too many elements"); - let len_fmt_bytes = len_fmt.serialize(); - let len_options = u16::try_from(options.len()).expect("`options` has too many elements"); - let len_options_bytes = len_options.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_PUT_DOCUMENT_DATA_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - len_data_bytes[0], - len_data_bytes[1], - len_data_bytes[2], - len_data_bytes[3], - len_fmt_bytes[0], - len_fmt_bytes[1], - len_options_bytes[0], - len_options_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + data.len(); - let length_so_far = length_so_far + doc_format.len(); - let length_so_far = length_so_far + options.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(data), IoSlice::new(doc_format), IoSlice::new(options), IoSlice::new(&padding0)], vec![])?) + let request0 = PrintPutDocumentDataRequest { + drawable, + data, + doc_format, + options, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintGetDocumentData request pub const PRINT_GET_DOCUMENT_DATA_REQUEST: u8 = 12; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintGetDocumentDataRequest { + pub context: Pcontext, + pub max_bytes: u32, +} +impl PrintGetDocumentDataRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let max_bytes_bytes = self.max_bytes.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_GET_DOCUMENT_DATA_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + max_bytes_bytes[0], + max_bytes_bytes[1], + max_bytes_bytes[2], + max_bytes_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_get_document_data(conn: &Conn, context: Pcontext, max_bytes: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let max_bytes_bytes = max_bytes.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_GET_DOCUMENT_DATA_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - max_bytes_bytes[0], - max_bytes_bytes[1], - max_bytes_bytes[2], - max_bytes_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintGetDocumentDataRequest { + context, + max_bytes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -980,115 +1230,189 @@ impl PrintGetDocumentDataReply { /// Opcode for the PrintStartPage request pub const PRINT_START_PAGE_REQUEST: u8 = 13; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintStartPageRequest { + pub window: xproto::Window, +} +impl PrintStartPageRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_START_PAGE_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_start_page(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_START_PAGE_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintStartPageRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintEndPage request pub const PRINT_END_PAGE_REQUEST: u8 = 14; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintEndPageRequest { + pub cancel: bool, +} +impl PrintEndPageRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let cancel_bytes = self.cancel.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_END_PAGE_REQUEST, + 0, + 0, + cancel_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_end_page(conn: &Conn, cancel: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let cancel_bytes = cancel.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_END_PAGE_REQUEST, - 0, - 0, - cancel_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintEndPageRequest { + cancel, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintSelectInput request pub const PRINT_SELECT_INPUT_REQUEST: u8 = 15; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintSelectInputRequest { + pub context: Pcontext, + pub event_mask: u32, +} +impl PrintSelectInputRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let event_mask_bytes = self.event_mask.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_SELECT_INPUT_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + event_mask_bytes[0], + event_mask_bytes[1], + event_mask_bytes[2], + event_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_select_input(conn: &Conn, context: Pcontext, event_mask: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let event_mask_bytes = event_mask.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_SELECT_INPUT_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - event_mask_bytes[0], - event_mask_bytes[1], - event_mask_bytes[2], - event_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintSelectInputRequest { + context, + event_mask, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintInputSelected request pub const PRINT_INPUT_SELECTED_REQUEST: u8 = 16; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintInputSelectedRequest { + pub context: Pcontext, +} +impl PrintInputSelectedRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_INPUT_SELECTED_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_input_selected(conn: &Conn, context: Pcontext) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_INPUT_SELECTED_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintInputSelectedRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1120,34 +1444,54 @@ impl TryFrom<&[u8]> for PrintInputSelectedReply { /// Opcode for the PrintGetAttributes request pub const PRINT_GET_ATTRIBUTES_REQUEST: u8 = 17; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintGetAttributesRequest { + pub context: Pcontext, + pub pool: u8, +} +impl PrintGetAttributesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let pool_bytes = self.pool.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_GET_ATTRIBUTES_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + pool_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_get_attributes(conn: &Conn, context: Pcontext, pool: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let pool_bytes = pool.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_GET_ATTRIBUTES_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - pool_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintGetAttributesRequest { + context, + pool, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1195,43 +1539,65 @@ impl PrintGetAttributesReply { /// Opcode for the PrintGetOneAttributes request pub const PRINT_GET_ONE_ATTRIBUTES_REQUEST: u8 = 19; -pub fn print_get_one_attributes<'c, Conn>(conn: &'c Conn, context: Pcontext, pool: u8, name: &[String8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PrintGetOneAttributesRequest<'input> { + pub context: Pcontext, + pub pool: u8, + pub name: &'input [String8], +} +impl<'input> PrintGetOneAttributesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let name_len = u32::try_from(self.name.len()).expect("`name` has too many elements"); + let name_len_bytes = name_len.serialize(); + let pool_bytes = self.pool.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_GET_ONE_ATTRIBUTES_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + name_len_bytes[0], + name_len_bytes[1], + name_len_bytes[2], + name_len_bytes[3], + pool_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) + } +} +pub fn print_get_one_attributes<'c, 'input, Conn>(conn: &'c Conn, context: Pcontext, pool: u8, name: &'input [String8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let name_len = u32::try_from(name.len()).expect("`name` has too many elements"); - let name_len_bytes = name_len.serialize(); - let pool_bytes = pool.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_GET_ONE_ATTRIBUTES_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - name_len_bytes[0], - name_len_bytes[1], - name_len_bytes[2], - name_len_bytes[3], - pool_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) + let request0 = PrintGetOneAttributesRequest { + context, + pool, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1279,70 +1645,114 @@ impl PrintGetOneAttributesReply { /// Opcode for the PrintSetAttributes request pub const PRINT_SET_ATTRIBUTES_REQUEST: u8 = 18; -pub fn print_set_attributes<'c, Conn>(conn: &'c Conn, context: Pcontext, string_len: u32, pool: u8, rule: u8, attributes: &[String8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PrintSetAttributesRequest<'input> { + pub context: Pcontext, + pub string_len: u32, + pub pool: u8, + pub rule: u8, + pub attributes: &'input [String8], +} +impl<'input> PrintSetAttributesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let string_len_bytes = self.string_len.serialize(); + let pool_bytes = self.pool.serialize(); + let rule_bytes = self.rule.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_SET_ATTRIBUTES_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + string_len_bytes[0], + string_len_bytes[1], + string_len_bytes[2], + string_len_bytes[3], + pool_bytes[0], + rule_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.attributes[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.attributes[..]).into(), padding0.into()], vec![])) + } +} +pub fn print_set_attributes<'c, 'input, Conn>(conn: &'c Conn, context: Pcontext, string_len: u32, pool: u8, rule: u8, attributes: &'input [String8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let string_len_bytes = string_len.serialize(); - let pool_bytes = pool.serialize(); - let rule_bytes = rule.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_SET_ATTRIBUTES_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - string_len_bytes[0], - string_len_bytes[1], - string_len_bytes[2], - string_len_bytes[3], - pool_bytes[0], - rule_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + attributes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(attributes), IoSlice::new(&padding0)], vec![])?) + let request0 = PrintSetAttributesRequest { + context, + string_len, + pool, + rule, + attributes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PrintGetPageDimensions request pub const PRINT_GET_PAGE_DIMENSIONS_REQUEST: u8 = 21; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintGetPageDimensionsRequest { + pub context: Pcontext, +} +impl PrintGetPageDimensionsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_GET_PAGE_DIMENSIONS_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_get_page_dimensions(conn: &Conn, context: Pcontext) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_GET_PAGE_DIMENSIONS_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintGetPageDimensionsRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1382,24 +1792,38 @@ impl TryFrom<&[u8]> for PrintGetPageDimensionsReply { /// Opcode for the PrintQueryScreens request pub const PRINT_QUERY_SCREENS_REQUEST: u8 = 22; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintQueryScreensRequest; +impl PrintQueryScreensRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_QUERY_SCREENS_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_query_screens(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - PRINT_QUERY_SCREENS_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintQueryScreensRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1446,34 +1870,54 @@ impl PrintQueryScreensReply { /// Opcode for the PrintSetImageResolution request pub const PRINT_SET_IMAGE_RESOLUTION_REQUEST: u8 = 23; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintSetImageResolutionRequest { + pub context: Pcontext, + pub image_resolution: u16, +} +impl PrintSetImageResolutionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let image_resolution_bytes = self.image_resolution.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_SET_IMAGE_RESOLUTION_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + image_resolution_bytes[0], + image_resolution_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_set_image_resolution(conn: &Conn, context: Pcontext, image_resolution: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let image_resolution_bytes = image_resolution.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_SET_IMAGE_RESOLUTION_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - image_resolution_bytes[0], - image_resolution_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintSetImageResolutionRequest { + context, + image_resolution, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1504,29 +1948,47 @@ impl TryFrom<&[u8]> for PrintSetImageResolutionReply { /// Opcode for the PrintGetImageResolution request pub const PRINT_GET_IMAGE_RESOLUTION_REQUEST: u8 = 24; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PrintGetImageResolutionRequest { + pub context: Pcontext, +} +impl PrintGetImageResolutionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_bytes = self.context.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PRINT_GET_IMAGE_RESOLUTION_REQUEST, + 0, + 0, + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn print_get_image_resolution(conn: &Conn, context: Pcontext) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_bytes = context.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PRINT_GET_IMAGE_RESOLUTION_REQUEST, - 0, - 0, - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PrintGetImageResolutionRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1853,7 +2315,7 @@ pub trait ConnectionExt: RequestConnection { { print_query_version(self) } - fn xprint_print_get_printer_list<'c>(&'c self, printer_name: &[String8], locale: &[String8]) -> Result, ConnectionError> + fn xprint_print_get_printer_list<'c, 'input>(&'c self, printer_name: &'input [String8], locale: &'input [String8]) -> Result, ConnectionError> { print_get_printer_list(self, printer_name, locale) } @@ -1861,7 +2323,7 @@ pub trait ConnectionExt: RequestConnection { { print_rehash_printer_list(self) } - fn xprint_create_context<'c>(&'c self, context_id: u32, printer_name: &[String8], locale: &[String8]) -> Result, ConnectionError> + fn xprint_create_context<'c, 'input>(&'c self, context_id: u32, printer_name: &'input [String8], locale: &'input [String8]) -> Result, ConnectionError> { create_context(self, context_id, printer_name, locale) } @@ -1897,7 +2359,7 @@ pub trait ConnectionExt: RequestConnection { { print_end_doc(self, cancel) } - fn xprint_print_put_document_data<'c>(&'c self, drawable: xproto::Drawable, data: &[u8], doc_format: &[String8], options: &[String8]) -> Result, ConnectionError> + fn xprint_print_put_document_data<'c, 'input>(&'c self, drawable: xproto::Drawable, data: &'input [u8], doc_format: &'input [String8], options: &'input [String8]) -> Result, ConnectionError> { print_put_document_data(self, drawable, data, doc_format, options) } @@ -1925,11 +2387,11 @@ pub trait ConnectionExt: RequestConnection { { print_get_attributes(self, context, pool) } - fn xprint_print_get_one_attributes<'c>(&'c self, context: Pcontext, pool: u8, name: &[String8]) -> Result, ConnectionError> + fn xprint_print_get_one_attributes<'c, 'input>(&'c self, context: Pcontext, pool: u8, name: &'input [String8]) -> Result, ConnectionError> { print_get_one_attributes(self, context, pool, name) } - fn xprint_print_set_attributes<'c>(&'c self, context: Pcontext, string_len: u32, pool: u8, rule: u8, attributes: &[String8]) -> Result, ConnectionError> + fn xprint_print_set_attributes<'c, 'input>(&'c self, context: Pcontext, string_len: u32, pool: u8, rule: u8, attributes: &'input [String8]) -> Result, ConnectionError> { print_set_attributes(self, context, string_len, pool, rule, attributes) } diff --git a/src/protocol/xproto.rs b/src/protocol/xproto.rs index eb8064f6..086ef7ce 100644 --- a/src/protocol/xproto.rs +++ b/src/protocol/xproto.rs @@ -21,7 +21,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::cookie::ListFontsWithInfoCookie; @@ -5750,8 +5750,6 @@ impl Gravity { } } -/// Opcode for the CreateWindow request -pub const CREATE_WINDOW_REQUEST: u8 = 1; /// Auxiliary and optional information for the `create_window` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct CreateWindowAux { @@ -5959,6 +5957,141 @@ impl CreateWindowAux { } } +/// Opcode for the CreateWindow request +pub const CREATE_WINDOW_REQUEST: u8 = 1; +/// Creates a window. +/// +/// Creates an unmapped window as child of the specified `parent` window. A +/// CreateNotify event will be generated. The new window is placed on top in the +/// stacking order with respect to siblings. +/// +/// The coordinate system has the X axis horizontal and the Y axis vertical with +/// the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms +/// of pixels, and coincide with pixel centers. Each window and pixmap has its own +/// coordinate system. For a window, the origin is inside the border at the inside, +/// upper-left corner. +/// +/// The created window is not yet displayed (mapped), call `xcb_map_window` to +/// display it. +/// +/// The created window will initially use the same cursor as its parent. +/// +/// # Fields +/// +/// * `wid` - The ID with which you will refer to the new window, created by +/// `xcb_generate_id`. +/// * `depth` - Specifies the new window's depth (TODO: what unit?). +/// +/// The special value `XCB_COPY_FROM_PARENT` means the depth is taken from the +/// `parent` window. +/// * `visual` - Specifies the id for the new window's visual. +/// +/// The special value `XCB_COPY_FROM_PARENT` means the visual is taken from the +/// `parent` window. +/// * `class` - +/// * `parent` - The parent window of the new window. +/// * `border_width` - TODO: +/// +/// Must be zero if the `class` is `InputOnly` or a `xcb_match_error_t` occurs. +/// * `x` - The X coordinate of the new window. +/// * `y` - The Y coordinate of the new window. +/// * `width` - The width of the new window. +/// * `height` - The height of the new window. +/// +/// # Errors +/// +/// * `Colormap` - TODO: reasons? +/// * `Match` - TODO: reasons? +/// * `Cursor` - TODO: reasons? +/// * `Pixmap` - TODO: reasons? +/// * `Value` - TODO: reasons? +/// * `Window` - TODO: reasons? +/// * `Alloc` - The X server could not allocate the requested resources (no memory?). +/// +/// # See +/// +/// * `xcb_generate_id`: function +/// * `MapWindow`: request +/// * `CreateNotify`: event +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateWindowRequest<'input> { + pub depth: u8, + pub wid: Window, + pub parent: Window, + pub x: i16, + pub y: i16, + pub width: u16, + pub height: u16, + pub border_width: u16, + pub class: WindowClass, + pub visual: Visualid, + pub value_list: &'input CreateWindowAux, +} +impl<'input> CreateWindowRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let depth_bytes = self.depth.serialize(); + let wid_bytes = self.wid.serialize(); + let parent_bytes = self.parent.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let border_width_bytes = self.border_width.serialize(); + let class_bytes = u16::from(self.class).serialize(); + let visual_bytes = self.visual.serialize(); + let value_mask = u32::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + CREATE_WINDOW_REQUEST, + depth_bytes[0], + 0, + 0, + wid_bytes[0], + wid_bytes[1], + wid_bytes[2], + wid_bytes[3], + parent_bytes[0], + parent_bytes[1], + parent_bytes[2], + parent_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + border_width_bytes[0], + border_width_bytes[1], + class_bytes[0], + class_bytes[1], + visual_bytes[0], + visual_bytes[1], + visual_bytes[2], + visual_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) + } +} /// Creates a window. /// /// Creates an unmapped window as child of the specified `parent` window. A @@ -6013,70 +6146,28 @@ impl CreateWindowAux { /// * `xcb_generate_id`: function /// * `MapWindow`: request /// * `CreateNotify`: event -pub fn create_window<'c, Conn>(conn: &'c Conn, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: WindowClass, visual: Visualid, value_list: &CreateWindowAux) -> Result, ConnectionError> +pub fn create_window<'c, 'input, Conn>(conn: &'c Conn, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: WindowClass, visual: Visualid, value_list: &'input CreateWindowAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let depth_bytes = depth.serialize(); - let wid_bytes = wid.serialize(); - let parent_bytes = parent.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let border_width_bytes = border_width.serialize(); - let class_bytes = u16::from(class).serialize(); - let visual_bytes = visual.serialize(); - let value_mask = u32::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - CREATE_WINDOW_REQUEST, - depth_bytes[0], - 0, - 0, - wid_bytes[0], - wid_bytes[1], - wid_bytes[2], - wid_bytes[3], - parent_bytes[0], - parent_bytes[1], - parent_bytes[2], - parent_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - border_width_bytes[0], - border_width_bytes[1], - class_bytes[0], - class_bytes[1], - visual_bytes[0], - visual_bytes[1], - visual_bytes[2], - visual_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateWindowRequest { + depth, + wid, + parent, + x, + y, + width, + height, + border_width, + class, + visual, + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } -/// Opcode for the ChangeWindowAttributes request -pub const CHANGE_WINDOW_ATTRIBUTES_REQUEST: u8 = 2; /// Auxiliary and optional information for the `change_window_attributes` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct ChangeWindowAttributesAux { @@ -6284,6 +6375,70 @@ impl ChangeWindowAttributesAux { } } +/// Opcode for the ChangeWindowAttributes request +pub const CHANGE_WINDOW_ATTRIBUTES_REQUEST: u8 = 2; +/// change window attributes. +/// +/// Changes the attributes specified by `value_mask` for the specified `window`. +/// +/// # Fields +/// +/// * `window` - The window to change. +/// * `value_mask` - +/// * `value_list` - Values for each of the attributes specified in the bitmask `value_mask`. The +/// order has to correspond to the order of possible `value_mask` bits. See the +/// example. +/// +/// # Errors +/// +/// * `Access` - TODO: reasons? +/// * `Colormap` - TODO: reasons? +/// * `Cursor` - TODO: reasons? +/// * `Match` - TODO: reasons? +/// * `Pixmap` - TODO: reasons? +/// * `Value` - TODO: reasons? +/// * `Window` - The specified `window` does not exist. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangeWindowAttributesRequest<'input> { + pub window: Window, + pub value_list: &'input ChangeWindowAttributesAux, +} +impl<'input> ChangeWindowAttributesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let value_mask = u32::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + CHANGE_WINDOW_ATTRIBUTES_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) + } +} /// change window attributes. /// /// Changes the attributes specified by `value_mask` for the specified `window`. @@ -6305,37 +6460,17 @@ impl ChangeWindowAttributesAux { /// * `Pixmap` - TODO: reasons? /// * `Value` - TODO: reasons? /// * `Window` - The specified `window` does not exist. -pub fn change_window_attributes<'c, Conn>(conn: &'c Conn, window: Window, value_list: &ChangeWindowAttributesAux) -> Result, ConnectionError> +pub fn change_window_attributes<'c, 'input, Conn>(conn: &'c Conn, window: Window, value_list: &'input ChangeWindowAttributesAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let value_mask = u32::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - CHANGE_WINDOW_ATTRIBUTES_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeWindowAttributesRequest { + window, + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -6417,27 +6552,58 @@ pub const GET_WINDOW_ATTRIBUTES_REQUEST: u8 = 3; /// /// * `Window` - The specified `window` does not exist. /// * `Drawable` - TODO: reasons? +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetWindowAttributesRequest { + pub window: Window, +} +impl GetWindowAttributesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + GET_WINDOW_ATTRIBUTES_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Gets window attributes. +/// +/// Gets the current attributes for the specified `window`. +/// +/// # Fields +/// +/// * `window` - The window to get the attributes from. +/// +/// # Errors +/// +/// * `Window` - The specified `window` does not exist. +/// * `Drawable` - TODO: reasons? pub fn get_window_attributes(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - GET_WINDOW_ATTRIBUTES_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetWindowAttributesRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } /// # Fields @@ -6538,52 +6704,112 @@ pub const DESTROY_WINDOW_REQUEST: u8 = 4; /// * `DestroyNotify`: event /// * `MapWindow`: request /// * `UnmapWindow`: request +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyWindowRequest { + pub window: Window, +} +impl DestroyWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + DESTROY_WINDOW_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Destroys a window. +/// +/// Destroys the specified window and all of its subwindows. A DestroyNotify event +/// is generated for each destroyed window (a DestroyNotify event is first generated +/// for any given window's inferiors). If the window was mapped, it will be +/// automatically unmapped before destroying. +/// +/// Calling DestroyWindow on the root window will do nothing. +/// +/// # Fields +/// +/// * `window` - The window to destroy. +/// +/// # Errors +/// +/// * `Window` - The specified window does not exist. +/// +/// # See +/// +/// * `DestroyNotify`: event +/// * `MapWindow`: request +/// * `UnmapWindow`: request pub fn destroy_window(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - DESTROY_WINDOW_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyWindowRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DestroySubwindows request pub const DESTROY_SUBWINDOWS_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroySubwindowsRequest { + pub window: Window, +} +impl DestroySubwindowsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + DESTROY_SUBWINDOWS_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_subwindows(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - DESTROY_SUBWINDOWS_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroySubwindowsRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -6680,48 +6906,167 @@ pub const CHANGE_SAVE_SET_REQUEST: u8 = 6; /// # See /// /// * `ReparentWindow`: request -pub fn change_save_set(conn: &Conn, mode: SetMode, window: Window) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, -{ - let length_so_far = 0; - let mode_bytes = u8::from(mode).serialize(); - let window_bytes = window.serialize(); - let mut request0 = [ - CHANGE_SAVE_SET_REQUEST, - mode_bytes[0], - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangeSaveSetRequest { + pub mode: SetMode, + pub window: Window, } - -/// Opcode for the ReparentWindow request -pub const REPARENT_WINDOW_REQUEST: u8 = 7; -/// Reparents a window. +impl ChangeSaveSetRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mode_bytes = u8::from(self.mode).serialize(); + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + CHANGE_SAVE_SET_REQUEST, + mode_bytes[0], + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Changes a client's save set. /// -/// Makes the specified window a child of the specified parent window. If the -/// window is mapped, it will automatically be unmapped before reparenting and -/// re-mapped after reparenting. The window is placed in the stacking order on top -/// with respect to sibling windows. +/// TODO: explain what the save set is for. /// -/// After reparenting, a ReparentNotify event is generated. +/// This function either adds or removes the specified window to the client's (your +/// application's) save set. /// /// # Fields /// -/// * `window` - The window to reparent. -/// * `parent` - The new parent of the window. -/// * `x` - The X position of the window within its new parent. -/// * `y` - The Y position of the window within its new parent. -/// +/// * `mode` - Insert to add the specified window to the save set or Delete to delete it from the save set. +/// * `window` - The window to add or delete to/from your save set. +/// +/// # Errors +/// +/// * `Match` - You created the specified window. This does not make sense, you can only add +/// windows created by other clients to your save set. +/// * `Value` - You specified an invalid mode. +/// * `Window` - The specified window does not exist. +/// +/// # See +/// +/// * `ReparentWindow`: request +pub fn change_save_set(conn: &Conn, mode: SetMode, window: Window) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, +{ + let request0 = ChangeSaveSetRequest { + mode, + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) +} + +/// Opcode for the ReparentWindow request +pub const REPARENT_WINDOW_REQUEST: u8 = 7; +/// Reparents a window. +/// +/// Makes the specified window a child of the specified parent window. If the +/// window is mapped, it will automatically be unmapped before reparenting and +/// re-mapped after reparenting. The window is placed in the stacking order on top +/// with respect to sibling windows. +/// +/// After reparenting, a ReparentNotify event is generated. +/// +/// # Fields +/// +/// * `window` - The window to reparent. +/// * `parent` - The new parent of the window. +/// * `x` - The X position of the window within its new parent. +/// * `y` - The Y position of the window within its new parent. +/// +/// # Errors +/// +/// * `Match` - The new parent window is not on the same screen as the old parent window. +/// +/// The new parent window is the specified window or an inferior of the specified window. +/// +/// The new parent is InputOnly and the window is not. +/// +/// The specified window has a ParentRelative background and the new parent window is not the same depth as the specified window. +/// * `Window` - The specified window does not exist. +/// +/// # See +/// +/// * `ReparentNotify`: event +/// * `MapWindow`: request +/// * `UnmapWindow`: request +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ReparentWindowRequest { + pub window: Window, + pub parent: Window, + pub x: i16, + pub y: i16, +} +impl ReparentWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let parent_bytes = self.parent.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let mut request0 = vec![ + REPARENT_WINDOW_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + parent_bytes[0], + parent_bytes[1], + parent_bytes[2], + parent_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Reparents a window. +/// +/// Makes the specified window a child of the specified parent window. If the +/// window is mapped, it will automatically be unmapped before reparenting and +/// re-mapped after reparenting. The window is placed in the stacking order on top +/// with respect to sibling windows. +/// +/// After reparenting, a ReparentNotify event is generated. +/// +/// # Fields +/// +/// * `window` - The window to reparent. +/// * `parent` - The new parent of the window. +/// * `x` - The X position of the window within its new parent. +/// * `y` - The Y position of the window within its new parent. +/// /// # Errors /// /// * `Match` - The new parent window is not on the same screen as the old parent window. @@ -6742,34 +7087,15 @@ pub fn reparent_window(conn: &Conn, window: Window, parent: Window, x: i16 where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let parent_bytes = parent.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let mut request0 = [ - REPARENT_WINDOW_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - parent_bytes[0], - parent_bytes[1], - parent_bytes[2], - parent_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ReparentWindowRequest { + window, + parent, + x, + y, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the MapWindow request @@ -6809,52 +7135,125 @@ pub const MAP_WINDOW_REQUEST: u8 = 8; /// * `MapNotify`: event /// * `Expose`: event /// * `UnmapWindow`: request +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct MapWindowRequest { + pub window: Window, +} +impl MapWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + MAP_WINDOW_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Makes a window visible. +/// +/// Maps the specified window. This means making the window visible (as long as its +/// parent is visible). +/// +/// This MapWindow request will be translated to a MapRequest request if a window +/// manager is running. The window manager then decides to either map the window or +/// not. Set the override-redirect window attribute to true if you want to bypass +/// this mechanism. +/// +/// If the window manager decides to map the window (or if no window manager is +/// running), a MapNotify event is generated. +/// +/// If the window becomes viewable and no earlier contents for it are remembered, +/// the X server tiles the window with its background. If the window's background +/// is undefined, the existing screen contents are not altered, and the X server +/// generates zero or more Expose events. +/// +/// If the window type is InputOutput, an Expose event will be generated when the +/// window becomes visible. The normal response to an Expose event should be to +/// repaint the window. +/// +/// # Fields +/// +/// * `window` - The window to make visible. +/// +/// # Errors +/// +/// * `Match` - The specified window does not exist. +/// +/// # See +/// +/// * `MapNotify`: event +/// * `Expose`: event +/// * `UnmapWindow`: request pub fn map_window(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - MAP_WINDOW_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = MapWindowRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the MapSubwindows request pub const MAP_SUBWINDOWS_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct MapSubwindowsRequest { + pub window: Window, +} +impl MapSubwindowsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + MAP_SUBWINDOWS_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn map_subwindows(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - MAP_SUBWINDOWS_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = MapSubwindowsRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UnmapWindow request @@ -6880,52 +7279,111 @@ pub const UNMAP_WINDOW_REQUEST: u8 = 10; /// * `UnmapNotify`: event /// * `Expose`: event /// * `MapWindow`: request +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UnmapWindowRequest { + pub window: Window, +} +impl UnmapWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + UNMAP_WINDOW_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Makes a window invisible. +/// +/// Unmaps the specified window. This means making the window invisible (and all +/// its child windows). +/// +/// Unmapping a window leads to the `UnmapNotify` event being generated. Also, +/// `Expose` events are generated for formerly obscured windows. +/// +/// # Fields +/// +/// * `window` - The window to make invisible. +/// +/// # Errors +/// +/// * `Window` - The specified window does not exist. +/// +/// # See +/// +/// * `UnmapNotify`: event +/// * `Expose`: event +/// * `MapWindow`: request pub fn unmap_window(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - UNMAP_WINDOW_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UnmapWindowRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UnmapSubwindows request pub const UNMAP_SUBWINDOWS_REQUEST: u8 = 11; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UnmapSubwindowsRequest { + pub window: Window, +} +impl UnmapSubwindowsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + UNMAP_SUBWINDOWS_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn unmap_subwindows(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - UNMAP_SUBWINDOWS_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UnmapSubwindowsRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -7078,8 +7536,6 @@ impl TryFrom for StackMode { } } -/// Opcode for the ConfigureWindow request -pub const CONFIGURE_WINDOW_REQUEST: u8 = 12; /// Auxiliary and optional information for the `configure_window` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct ConfigureWindowAux { @@ -7191,6 +7647,8 @@ impl ConfigureWindowAux { } } +/// Opcode for the ConfigureWindow request +pub const CONFIGURE_WINDOW_REQUEST: u8 = 12; /// Configures window attributes. /// /// Configures a window's size, position, border width and stacking order. @@ -7241,62 +7699,133 @@ impl ConfigureWindowAux { /// xcb_flush(c); /// } /// ``` -pub fn configure_window<'c, Conn>(conn: &'c Conn, window: Window, value_list: &ConfigureWindowAux) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, -{ - let length_so_far = 0; - let window_bytes = window.serialize(); - let value_mask = u16::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - CONFIGURE_WINDOW_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) -} - #[derive(Debug, Clone, Copy, PartialEq, Eq)] -#[repr(u8)] -pub enum Circulate { - RaiseLowest = 0, - LowerHighest = 1, -} -impl From for bool { - fn from(input: Circulate) -> Self { - match input { - Circulate::RaiseLowest => false, - Circulate::LowerHighest => true, - } - } +pub struct ConfigureWindowRequest<'input> { + pub window: Window, + pub value_list: &'input ConfigureWindowAux, } -impl From for u8 { - fn from(input: Circulate) -> Self { - match input { - Circulate::RaiseLowest => 0, - Circulate::LowerHighest => 1, - } +impl<'input> ConfigureWindowRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let value_mask = u16::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + CONFIGURE_WINDOW_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) } } -impl From for Option { +/// Configures window attributes. +/// +/// Configures a window's size, position, border width and stacking order. +/// +/// # Fields +/// +/// * `window` - The window to configure. +/// * `value_mask` - Bitmask of attributes to change. +/// * `value_list` - New values, corresponding to the attributes in value_mask. The order has to +/// correspond to the order of possible `value_mask` bits. See the example. +/// +/// # Errors +/// +/// * `Match` - You specified a Sibling without also specifying StackMode or the window is not +/// actually a Sibling. +/// * `Window` - The specified window does not exist. TODO: any other reason? +/// * `Value` - TODO: reasons? +/// +/// # See +/// +/// * `MapNotify`: event +/// * `Expose`: event +/// +/// # Example +/// +/// ```text +/// /* +/// * Configures the given window to the left upper corner +/// * with a size of 1024x768 pixels. +/// * +/// */ +/// void my_example(xcb_connection_t *c, xcb_window_t window) { +/// uint16_t mask = 0; +/// +/// mask |= XCB_CONFIG_WINDOW_X; +/// mask |= XCB_CONFIG_WINDOW_Y; +/// mask |= XCB_CONFIG_WINDOW_WIDTH; +/// mask |= XCB_CONFIG_WINDOW_HEIGHT; +/// +/// const uint32_t values[] = { +/// 0, /* x */ +/// 0, /* y */ +/// 1024, /* width */ +/// 768 /* height */ +/// }; +/// +/// xcb_configure_window(c, window, mask, values); +/// xcb_flush(c); +/// } +/// ``` +pub fn configure_window<'c, 'input, Conn>(conn: &'c Conn, window: Window, value_list: &'input ConfigureWindowAux) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, +{ + let request0 = ConfigureWindowRequest { + window, + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[repr(u8)] +pub enum Circulate { + RaiseLowest = 0, + LowerHighest = 1, +} +impl From for bool { + fn from(input: Circulate) -> Self { + match input { + Circulate::RaiseLowest => false, + Circulate::LowerHighest => true, + } + } +} +impl From for u8 { + fn from(input: Circulate) -> Self { + match input { + Circulate::RaiseLowest => 0, + Circulate::LowerHighest => 1, + } + } +} +impl From for Option { fn from(input: Circulate) -> Self { Some(u8::from(input)) } @@ -7363,28 +7892,66 @@ pub const CIRCULATE_WINDOW_REQUEST: u8 = 13; /// /// * `Window` - The specified `window` does not exist. /// * `Value` - The specified `direction` is invalid. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CirculateWindowRequest { + pub direction: Circulate, + pub window: Window, +} +impl CirculateWindowRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let direction_bytes = u8::from(self.direction).serialize(); + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + CIRCULATE_WINDOW_REQUEST, + direction_bytes[0], + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Change window stacking order. +/// +/// If `direction` is `XCB_CIRCULATE_RAISE_LOWEST`, the lowest mapped child (if +/// any) will be raised to the top of the stack. +/// +/// If `direction` is `XCB_CIRCULATE_LOWER_HIGHEST`, the highest mapped child will +/// be lowered to the bottom of the stack. +/// +/// # Fields +/// +/// * `direction` - +/// * `window` - The window to raise/lower (depending on `direction`). +/// +/// # Errors +/// +/// * `Window` - The specified `window` does not exist. +/// * `Value` - The specified `direction` is invalid. pub fn circulate_window(conn: &Conn, direction: Circulate, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let direction_bytes = u8::from(direction).serialize(); - let window_bytes = window.serialize(); - let mut request0 = [ - CIRCULATE_WINDOW_REQUEST, - direction_bytes[0], - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CirculateWindowRequest { + direction, + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetGeometry request @@ -7425,27 +7992,82 @@ pub const GET_GEOMETRY_REQUEST: u8 = 14; /// free(reply); /// } /// ``` +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetGeometryRequest { + pub drawable: Drawable, +} +impl GetGeometryRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + GET_GEOMETRY_REQUEST, + 0, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Get current window geometry. +/// +/// Gets the current geometry of the specified drawable (either `Window` or `Pixmap`). +/// +/// # Fields +/// +/// * `drawable` - The drawable (`Window` or `Pixmap`) of which the geometry will be received. +/// +/// # Errors +/// +/// * `Drawable` - TODO: reasons? +/// * `Window` - TODO: reasons? +/// +/// # See +/// +/// * `xwininfo`: program +/// +/// # Example +/// +/// ```text +/// /* +/// * Displays the x and y position of the given window. +/// * +/// */ +/// void my_example(xcb_connection_t *c, xcb_window_t window) { +/// xcb_get_geometry_cookie_t cookie; +/// xcb_get_geometry_reply_t *reply; +/// +/// cookie = xcb_get_geometry(c, window); +/// /* ... do other work here if possible ... */ +/// if ((reply = xcb_get_geometry_reply(c, cookie, NULL))) { +/// printf("This window is at %d, %d\\n", reply->x, reply->y); +/// } +/// free(reply); +/// } +/// ``` pub fn get_geometry(conn: &Conn, drawable: Drawable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - GET_GEOMETRY_REQUEST, - 0, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetGeometryRequest { + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } /// # Fields @@ -7537,27 +8159,83 @@ pub const QUERY_TREE_REQUEST: u8 = 15; /// } /// } /// ``` +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryTreeRequest { + pub window: Window, +} +impl QueryTreeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + QUERY_TREE_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// query the window tree. +/// +/// Gets the root window ID, parent window ID and list of children windows for the +/// specified `window`. The children are listed in bottom-to-top stacking order. +/// +/// # Fields +/// +/// * `window` - The `window` to query. +/// +/// # See +/// +/// * `xwininfo`: program +/// +/// # Example +/// +/// ```text +/// /* +/// * Displays the root, parent and children of the specified window. +/// * +/// */ +/// void my_example(xcb_connection_t *conn, xcb_window_t window) { +/// xcb_query_tree_cookie_t cookie; +/// xcb_query_tree_reply_t *reply; +/// +/// cookie = xcb_query_tree(conn, window); +/// if ((reply = xcb_query_tree_reply(conn, cookie, NULL))) { +/// printf("root = 0x%08x\\n", reply->root); +/// printf("parent = 0x%08x\\n", reply->parent); +/// +/// xcb_window_t *children = xcb_query_tree_children(reply); +/// for (int i = 0; i < xcb_query_tree_children_length(reply); i++) +/// printf("child window = 0x%08x\\n", children[i]); +/// +/// free(reply); +/// } +/// } +/// ``` pub fn query_tree(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - QUERY_TREE_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryTreeRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } /// # Fields @@ -7658,85 +8336,170 @@ pub const INTERN_ATOM_REQUEST: u8 = 16; /// } /// } /// ``` -pub fn intern_atom<'c, Conn>(conn: &'c Conn, only_if_exists: bool, name: &[u8]) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, -{ - let length_so_far = 0; - let only_if_exists_bytes = only_if_exists.serialize(); - let name_len = u16::try_from(name.len()).expect("`name` has too many elements"); - let name_len_bytes = name_len.serialize(); - let mut request0 = [ - INTERN_ATOM_REQUEST, - only_if_exists_bytes[0], - 0, - 0, - name_len_bytes[0], - name_len_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct InternAtomReply { - pub response_type: u8, - pub sequence: u16, - pub length: u32, - pub atom: Atom, -} -impl TryParse for InternAtomReply { - fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> { - let (response_type, remaining) = u8::try_parse(remaining)?; - let remaining = remaining.get(1..).ok_or(ParseError::ParseError)?; - let (sequence, remaining) = u16::try_parse(remaining)?; - let (length, remaining) = u32::try_parse(remaining)?; - let (atom, remaining) = Atom::try_parse(remaining)?; - let result = InternAtomReply { response_type, sequence, length, atom }; - Ok((result, remaining)) - } +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct InternAtomRequest<'input> { + pub only_if_exists: bool, + pub name: &'input [u8], } -impl TryFrom<&[u8]> for InternAtomReply { - type Error = ParseError; - fn try_from(value: &[u8]) -> Result { - Ok(Self::try_parse(value)?.0) +impl<'input> InternAtomRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let only_if_exists_bytes = self.only_if_exists.serialize(); + let name_len = u16::try_from(self.name.len()).expect("`name` has too many elements"); + let name_len_bytes = name_len.serialize(); + let mut request0 = vec![ + INTERN_ATOM_REQUEST, + only_if_exists_bytes[0], + 0, + 0, + name_len_bytes[0], + name_len_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) } } - -/// Opcode for the GetAtomName request -pub const GET_ATOM_NAME_REQUEST: u8 = 17; -pub fn get_atom_name(conn: &Conn, atom: Atom) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, -{ - let length_so_far = 0; - let atom_bytes = atom.serialize(); - let mut request0 = [ - GET_ATOM_NAME_REQUEST, - 0, - 0, - 0, - atom_bytes[0], - atom_bytes[1], - atom_bytes[2], - atom_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) -} - -#[derive(Debug, Clone, PartialEq, Eq)] +/// Get atom identifier by name. +/// +/// Retrieves the identifier (xcb_atom_t TODO) for the atom with the specified +/// name. Atoms are used in protocols like EWMH, for example to store window titles +/// (`_NET_WM_NAME` atom) as property of a window. +/// +/// If `only_if_exists` is 0, the atom will be created if it does not already exist. +/// If `only_if_exists` is 1, `XCB_ATOM_NONE` will be returned if the atom does +/// not yet exist. +/// +/// # Fields +/// +/// * `name_len` - The length of the following `name`. +/// * `name` - The name of the atom. +/// * `only_if_exists` - Return a valid atom id only if the atom already exists. +/// +/// # Errors +/// +/// * `Alloc` - TODO: reasons? +/// * `Value` - A value other than 0 or 1 was specified for `only_if_exists`. +/// +/// # See +/// +/// * `xlsatoms`: program +/// * `GetAtomName`: request +/// +/// # Example +/// +/// ```text +/// /* +/// * Resolves the _NET_WM_NAME atom. +/// * +/// */ +/// void my_example(xcb_connection_t *c) { +/// xcb_intern_atom_cookie_t cookie; +/// xcb_intern_atom_reply_t *reply; +/// +/// cookie = xcb_intern_atom(c, 0, strlen("_NET_WM_NAME"), "_NET_WM_NAME"); +/// /* ... do other work here if possible ... */ +/// if ((reply = xcb_intern_atom_reply(c, cookie, NULL))) { +/// printf("The _NET_WM_NAME atom has ID %u\n", reply->atom); +/// free(reply); +/// } +/// } +/// ``` +pub fn intern_atom<'c, 'input, Conn>(conn: &'c Conn, only_if_exists: bool, name: &'input [u8]) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, +{ + let request0 = InternAtomRequest { + only_if_exists, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct InternAtomReply { + pub response_type: u8, + pub sequence: u16, + pub length: u32, + pub atom: Atom, +} +impl TryParse for InternAtomReply { + fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> { + let (response_type, remaining) = u8::try_parse(remaining)?; + let remaining = remaining.get(1..).ok_or(ParseError::ParseError)?; + let (sequence, remaining) = u16::try_parse(remaining)?; + let (length, remaining) = u32::try_parse(remaining)?; + let (atom, remaining) = Atom::try_parse(remaining)?; + let result = InternAtomReply { response_type, sequence, length, atom }; + Ok((result, remaining)) + } +} +impl TryFrom<&[u8]> for InternAtomReply { + type Error = ParseError; + fn try_from(value: &[u8]) -> Result { + Ok(Self::try_parse(value)?.0) + } +} + +/// Opcode for the GetAtomName request +pub const GET_ATOM_NAME_REQUEST: u8 = 17; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetAtomNameRequest { + pub atom: Atom, +} +impl GetAtomNameRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let atom_bytes = self.atom.serialize(); + let mut request0 = vec![ + GET_ATOM_NAME_REQUEST, + 0, + 0, + 0, + atom_bytes[0], + atom_bytes[1], + atom_bytes[2], + atom_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +pub fn get_atom_name(conn: &Conn, atom: Atom) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, +{ + let request0 = GetAtomNameRequest { + atom, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) +} + +#[derive(Debug, Clone, PartialEq, Eq)] pub struct GetAtomNameReply { pub response_type: u8, pub sequence: u16, @@ -7906,7 +8669,119 @@ pub const CHANGE_PROPERTY_REQUEST: u8 = 18; /// xcb_flush(conn); /// } /// ``` -pub fn change_property<'c, Conn, A, B>(conn: &'c Conn, mode: PropMode, window: Window, property: A, type_: B, format: u8, data_len: u32, data: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangePropertyRequest<'input> { + pub mode: PropMode, + pub window: Window, + pub property: Atom, + pub type_: Atom, + pub format: u8, + pub data_len: u32, + pub data: &'input [u8], +} +impl<'input> ChangePropertyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mode_bytes = u8::from(self.mode).serialize(); + let window_bytes = self.window.serialize(); + let property_bytes = self.property.serialize(); + let type_bytes = self.type_.serialize(); + let format_bytes = self.format.serialize(); + let data_len_bytes = self.data_len.serialize(); + let mut request0 = vec![ + CHANGE_PROPERTY_REQUEST, + mode_bytes[0], + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + format_bytes[0], + 0, + 0, + 0, + data_len_bytes[0], + data_len_bytes[1], + data_len_bytes[2], + data_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(self.data.len(), usize::try_from(self.data_len.checked_mul(u32::from(self.format)).unwrap().checked_div(8u32).unwrap()).unwrap(), "`data` has an incorrect length"); + let length_so_far = length_so_far + (&self.data[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.data[..]).into(), padding0.into()], vec![])) + } +} +/// Changes a window property. +/// +/// Sets or updates a property on the specified `window`. Properties are for +/// example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`). +/// Protocols such as EWMH also use properties - for example EWMH defines the +/// window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property. +/// +/// # Fields +/// +/// * `window` - The window whose property you want to change. +/// * `mode` - +/// * `property` - The property you want to change (an atom). +/// * `type` - The type of the property you want to change (an atom). +/// * `format` - Specifies whether the data should be viewed as a list of 8-bit, 16-bit or +/// 32-bit quantities. Possible values are 8, 16 and 32. This information allows +/// the X server to correctly perform byte-swap operations as necessary. +/// * `data_len` - Specifies the number of elements (see `format`). +/// * `data` - The property data. +/// +/// # Errors +/// +/// * `Match` - TODO: reasons? +/// * `Value` - TODO: reasons? +/// * `Window` - The specified `window` does not exist. +/// * `Atom` - `property` or `type` do not refer to a valid atom. +/// * `Alloc` - The X server could not store the property (no memory?). +/// +/// # See +/// +/// * `InternAtom`: request +/// * `xprop`: program +/// +/// # Example +/// +/// ```text +/// /* +/// * Sets the WM_NAME property of the window to "XCB Example". +/// * +/// */ +/// void my_example(xcb_connection_t *conn, xcb_window_t window) { +/// xcb_change_property(conn, +/// XCB_PROP_MODE_REPLACE, +/// window, +/// XCB_ATOM_WM_NAME, +/// XCB_ATOM_STRING, +/// 8, +/// strlen("XCB Example"), +/// "XCB Example"); +/// xcb_flush(conn); +/// } +/// ``` +pub fn change_property<'c, 'input, Conn, A, B>(conn: &'c Conn, mode: PropMode, window: Window, property: A, type_: B, format: u8, data_len: u32, data: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, @@ -7914,78 +8789,69 @@ where { let property: Atom = property.into(); let type_: Atom = type_.into(); - let length_so_far = 0; - let mode_bytes = u8::from(mode).serialize(); - let window_bytes = window.serialize(); - let property_bytes = property.serialize(); - let type_bytes = type_.serialize(); - let format_bytes = format.serialize(); - let data_len_bytes = data_len.serialize(); - let mut request0 = [ - CHANGE_PROPERTY_REQUEST, - mode_bytes[0], - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - format_bytes[0], - 0, - 0, - 0, - data_len_bytes[0], - data_len_bytes[1], - data_len_bytes[2], - data_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(data.len(), usize::try_from(data_len.checked_mul(u32::from(format)).unwrap().checked_div(8u32).unwrap()).unwrap(), "`data` has an incorrect length"); - let length_so_far = length_so_far + data.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(data), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangePropertyRequest { + mode, + window, + property, + type_, + format, + data_len, + data, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the DeleteProperty request pub const DELETE_PROPERTY_REQUEST: u8 = 19; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DeletePropertyRequest { + pub window: Window, + pub property: Atom, +} +impl DeletePropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let property_bytes = self.property.serialize(); + let mut request0 = vec![ + DELETE_PROPERTY_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn delete_property(conn: &Conn, window: Window, property: Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let property_bytes = property.serialize(); - let mut request0 = [ - DELETE_PROPERTY_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DeletePropertyRequest { + window, + property, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -8117,97 +8983,194 @@ pub const GET_PROPERTY_REQUEST: u8 = 20; /// free(reply); /// } /// ``` -pub fn get_property(conn: &Conn, delete: bool, window: Window, property: A, type_: B, long_offset: u32, long_length: u32) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, - A: Into, - B: Into, -{ - let property: Atom = property.into(); - let type_: Atom = type_.into(); - let length_so_far = 0; - let delete_bytes = delete.serialize(); - let window_bytes = window.serialize(); - let property_bytes = property.serialize(); - let type_bytes = type_.serialize(); - let long_offset_bytes = long_offset.serialize(); - let long_length_bytes = long_length.serialize(); - let mut request0 = [ - GET_PROPERTY_REQUEST, - delete_bytes[0], - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - type_bytes[0], - type_bytes[1], - type_bytes[2], - type_bytes[3], - long_offset_bytes[0], - long_offset_bytes[1], - long_offset_bytes[2], - long_offset_bytes[3], - long_length_bytes[0], - long_length_bytes[1], - long_length_bytes[2], - long_length_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPropertyRequest { + pub delete: bool, + pub window: Window, + pub property: Atom, + pub type_: Atom, + pub long_offset: u32, + pub long_length: u32, } -impl GetPropertyReply { - /// Iterate over the contained value if its format is 8. - /// - /// This function checks if the `format` member of the reply - /// is 8. If it it is not, `None` is returned. Otherwise - /// and iterator is returned that interprets the value in - /// this reply as type `u8`. - /// - /// # Examples - /// - /// Successfully iterate over the value: - /// ``` - /// // First, we have to 'invent' a GetPropertyReply. - /// let reply = x11rb::protocol::xproto::GetPropertyReply { - /// response_type: 1, - /// format: 8, - /// sequence: 0, - /// length: 0, // This value is incorrect - /// type_: 0, // This value is incorrect - /// bytes_after: 0, - /// value_len: 4, - /// value: vec![1, 2, 3, 4], - /// }; - /// - /// // This is the actual example: Iterate over the value. - /// let mut iter = reply.value8().unwrap(); - /// assert_eq!(iter.next(), Some(1)); - /// assert_eq!(iter.next(), Some(2)); - /// assert_eq!(iter.next(), Some(3)); - /// assert_eq!(iter.next(), Some(4)); - /// assert_eq!(iter.next(), None); - /// ``` - /// - /// An iterator is only returned when the `format` is correct. - /// The following example shows this. - /// ``` - /// // First, we have to 'invent' a GetPropertyReply. - /// let reply = x11rb::protocol::xproto::GetPropertyReply { - /// response_type: 1, - /// format: 42, // Not allowed in X11, but used for the example - /// sequence: 0, - /// length: 0, // This value is incorrect - /// type_: 0, // This value is incorrect - /// bytes_after: 0, +impl GetPropertyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let delete_bytes = self.delete.serialize(); + let window_bytes = self.window.serialize(); + let property_bytes = self.property.serialize(); + let type_bytes = self.type_.serialize(); + let long_offset_bytes = self.long_offset.serialize(); + let long_length_bytes = self.long_length.serialize(); + let mut request0 = vec![ + GET_PROPERTY_REQUEST, + delete_bytes[0], + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + type_bytes[0], + type_bytes[1], + type_bytes[2], + type_bytes[3], + long_offset_bytes[0], + long_offset_bytes[1], + long_offset_bytes[2], + long_offset_bytes[3], + long_length_bytes[0], + long_length_bytes[1], + long_length_bytes[2], + long_length_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Gets a window property. +/// +/// Gets the specified `property` from the specified `window`. Properties are for +/// example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`). +/// Protocols such as EWMH also use properties - for example EWMH defines the +/// window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property. +/// +/// TODO: talk about `type` +/// +/// TODO: talk about `delete` +/// +/// TODO: talk about the offset/length thing. what's a valid use case? +/// +/// # Fields +/// +/// * `window` - The window whose property you want to get. +/// * `delete` - Whether the property should actually be deleted. For deleting a property, the +/// specified `type` has to match the actual property type. +/// * `property` - The property you want to get (an atom). +/// * `type` - The type of the property you want to get (an atom). +/// * `long_offset` - Specifies the offset (in 32-bit multiples) in the specified property where the +/// data is to be retrieved. +/// * `long_length` - Specifies how many 32-bit multiples of data should be retrieved (e.g. if you +/// set `long_length` to 4, you will receive 16 bytes of data). +/// +/// # Errors +/// +/// * `Window` - The specified `window` does not exist. +/// * `Atom` - `property` or `type` do not refer to a valid atom. +/// * `Value` - The specified `long_offset` is beyond the actual property length (e.g. the +/// property has a length of 3 bytes and you are setting `long_offset` to 1, +/// resulting in a byte offset of 4). +/// +/// # See +/// +/// * `InternAtom`: request +/// * `xprop`: program +/// +/// # Example +/// +/// ```text +/// /* +/// * Prints the WM_NAME property of the window. +/// * +/// */ +/// void my_example(xcb_connection_t *c, xcb_window_t window) { +/// xcb_get_property_cookie_t cookie; +/// xcb_get_property_reply_t *reply; +/// +/// /* These atoms are predefined in the X11 protocol. */ +/// xcb_atom_t property = XCB_ATOM_WM_NAME; +/// xcb_atom_t type = XCB_ATOM_STRING; +/// +/// // TODO: a reasonable long_length for WM_NAME? +/// cookie = xcb_get_property(c, 0, window, property, type, 0, 0); +/// if ((reply = xcb_get_property_reply(c, cookie, NULL))) { +/// int len = xcb_get_property_value_length(reply); +/// if (len == 0) { +/// printf("TODO\\n"); +/// free(reply); +/// return; +/// } +/// printf("WM_NAME is %.*s\\n", len, +/// (char*)xcb_get_property_value(reply)); +/// } +/// free(reply); +/// } +/// ``` +pub fn get_property(conn: &Conn, delete: bool, window: Window, property: A, type_: B, long_offset: u32, long_length: u32) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, + A: Into, + B: Into, +{ + let property: Atom = property.into(); + let type_: Atom = type_.into(); + let request0 = GetPropertyRequest { + delete, + window, + property, + type_, + long_offset, + long_length, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) +} +impl GetPropertyReply { + /// Iterate over the contained value if its format is 8. + /// + /// This function checks if the `format` member of the reply + /// is 8. If it it is not, `None` is returned. Otherwise + /// and iterator is returned that interprets the value in + /// this reply as type `u8`. + /// + /// # Examples + /// + /// Successfully iterate over the value: + /// ``` + /// // First, we have to 'invent' a GetPropertyReply. + /// let reply = x11rb::protocol::xproto::GetPropertyReply { + /// response_type: 1, + /// format: 8, + /// sequence: 0, + /// length: 0, // This value is incorrect + /// type_: 0, // This value is incorrect + /// bytes_after: 0, + /// value_len: 4, + /// value: vec![1, 2, 3, 4], + /// }; + /// + /// // This is the actual example: Iterate over the value. + /// let mut iter = reply.value8().unwrap(); + /// assert_eq!(iter.next(), Some(1)); + /// assert_eq!(iter.next(), Some(2)); + /// assert_eq!(iter.next(), Some(3)); + /// assert_eq!(iter.next(), Some(4)); + /// assert_eq!(iter.next(), None); + /// ``` + /// + /// An iterator is only returned when the `format` is correct. + /// The following example shows this. + /// ``` + /// // First, we have to 'invent' a GetPropertyReply. + /// let reply = x11rb::protocol::xproto::GetPropertyReply { + /// response_type: 1, + /// format: 42, // Not allowed in X11, but used for the example + /// sequence: 0, + /// length: 0, // This value is incorrect + /// type_: 0, // This value is incorrect + /// bytes_after: 0, /// value_len: 4, /// value: vec![1, 2, 3, 4], /// }; @@ -8374,27 +9337,46 @@ impl TryFrom<&[u8]> for GetPropertyReply { /// Opcode for the ListProperties request pub const LIST_PROPERTIES_REQUEST: u8 = 21; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListPropertiesRequest { + pub window: Window, +} +impl ListPropertiesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + LIST_PROPERTIES_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_properties(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - LIST_PROPERTIES_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListPropertiesRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -8470,6 +9452,77 @@ pub const SET_SELECTION_OWNER_REQUEST: u8 = 22; /// # See /// /// * `SetSelectionOwner`: request +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetSelectionOwnerRequest { + pub owner: Window, + pub selection: Atom, + pub time: Timestamp, +} +impl SetSelectionOwnerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let owner_bytes = self.owner.serialize(); + let selection_bytes = self.selection.serialize(); + let time_bytes = self.time.serialize(); + let mut request0 = vec![ + SET_SELECTION_OWNER_REQUEST, + 0, + 0, + 0, + owner_bytes[0], + owner_bytes[1], + owner_bytes[2], + owner_bytes[3], + selection_bytes[0], + selection_bytes[1], + selection_bytes[2], + selection_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Sets the owner of a selection. +/// +/// Makes `window` the owner of the selection `selection` and updates the +/// last-change time of the specified selection. +/// +/// TODO: briefly explain what a selection is. +/// +/// # Fields +/// +/// * `selection` - The selection. +/// * `owner` - The new owner of the selection. +/// +/// The special value `XCB_NONE` means that the selection will have no owner. +/// * `time` - Timestamp to avoid race conditions when running X over the network. +/// +/// The selection will not be changed if `time` is earlier than the current +/// last-change time of the `selection` or is later than the current X server time. +/// Otherwise, the last-change time is set to the specified time. +/// +/// The special value `XCB_CURRENT_TIME` will be replaced with the current server +/// time. +/// +/// # Errors +/// +/// * `Atom` - `selection` does not refer to a valid atom. +/// +/// # See +/// +/// * `SetSelectionOwner`: request pub fn set_selection_owner(conn: &Conn, owner: A, selection: Atom, time: B) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -8478,33 +9531,14 @@ where { let owner: Window = owner.into(); let time: Timestamp = time.into(); - let length_so_far = 0; - let owner_bytes = owner.serialize(); - let selection_bytes = selection.serialize(); - let time_bytes = time.serialize(); - let mut request0 = [ - SET_SELECTION_OWNER_REQUEST, - 0, - 0, - 0, - owner_bytes[0], - owner_bytes[1], - owner_bytes[2], - owner_bytes[3], - selection_bytes[0], - selection_bytes[1], - selection_bytes[2], - selection_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetSelectionOwnerRequest { + owner, + selection, + time, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetSelectionOwner request @@ -8526,27 +9560,63 @@ pub const GET_SELECTION_OWNER_REQUEST: u8 = 23; /// # See /// /// * `SetSelectionOwner`: request +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetSelectionOwnerRequest { + pub selection: Atom, +} +impl GetSelectionOwnerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let selection_bytes = self.selection.serialize(); + let mut request0 = vec![ + GET_SELECTION_OWNER_REQUEST, + 0, + 0, + 0, + selection_bytes[0], + selection_bytes[1], + selection_bytes[2], + selection_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Gets the owner of a selection. +/// +/// Gets the owner of the specified selection. +/// +/// TODO: briefly explain what a selection is. +/// +/// # Fields +/// +/// * `selection` - The selection. +/// +/// # Errors +/// +/// * `Atom` - `selection` does not refer to a valid atom. +/// +/// # See +/// +/// * `SetSelectionOwner`: request pub fn get_selection_owner(conn: &Conn, selection: Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let selection_bytes = selection.serialize(); - let mut request0 = [ - GET_SELECTION_OWNER_REQUEST, - 0, - 0, - 0, - selection_bytes[0], - selection_bytes[1], - selection_bytes[2], - selection_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetSelectionOwnerRequest { + selection, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } /// # Fields @@ -8579,58 +9649,85 @@ impl TryFrom<&[u8]> for GetSelectionOwnerReply { /// Opcode for the ConvertSelection request pub const CONVERT_SELECTION_REQUEST: u8 = 24; -pub fn convert_selection(conn: &Conn, requestor: Window, selection: Atom, target: Atom, property: A, time: B) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, - A: Into, - B: Into, -{ - let property: Atom = property.into(); - let time: Timestamp = time.into(); - let length_so_far = 0; - let requestor_bytes = requestor.serialize(); - let selection_bytes = selection.serialize(); - let target_bytes = target.serialize(); - let property_bytes = property.serialize(); - let time_bytes = time.serialize(); - let mut request0 = [ - CONVERT_SELECTION_REQUEST, - 0, - 0, - 0, - requestor_bytes[0], - requestor_bytes[1], - requestor_bytes[2], - requestor_bytes[3], - selection_bytes[0], - selection_bytes[1], - selection_bytes[2], - selection_bytes[3], - target_bytes[0], - target_bytes[1], - target_bytes[2], - target_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) -} - #[derive(Debug, Clone, Copy, PartialEq, Eq)] -#[repr(u8)] -pub enum SendEventDest { - PointerWindow = 0, - ItemFocus = 1, +pub struct ConvertSelectionRequest { + pub requestor: Window, + pub selection: Atom, + pub target: Atom, + pub property: Atom, + pub time: Timestamp, +} +impl ConvertSelectionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let requestor_bytes = self.requestor.serialize(); + let selection_bytes = self.selection.serialize(); + let target_bytes = self.target.serialize(); + let property_bytes = self.property.serialize(); + let time_bytes = self.time.serialize(); + let mut request0 = vec![ + CONVERT_SELECTION_REQUEST, + 0, + 0, + 0, + requestor_bytes[0], + requestor_bytes[1], + requestor_bytes[2], + requestor_bytes[3], + selection_bytes[0], + selection_bytes[1], + selection_bytes[2], + selection_bytes[3], + target_bytes[0], + target_bytes[1], + target_bytes[2], + target_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +pub fn convert_selection(conn: &Conn, requestor: Window, selection: Atom, target: Atom, property: A, time: B) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, + A: Into, + B: Into, +{ + let property: Atom = property.into(); + let time: Timestamp = time.into(); + let request0 = ConvertSelectionRequest { + requestor, + selection, + target, + property, + time, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[repr(u8)] +pub enum SendEventDest { + PointerWindow = 0, + ItemFocus = 1, } impl From for bool { fn from(input: SendEventDest) -> Self { @@ -8771,6 +9868,119 @@ pub const SEND_EVENT_REQUEST: u8 = 25; /// free(event); /// } /// ``` +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SendEventRequest<'input> { + pub propagate: bool, + pub destination: Window, + pub event_mask: u32, + pub event: &'input [u8; 32], +} +impl<'input> SendEventRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let propagate_bytes = self.propagate.serialize(); + let destination_bytes = self.destination.serialize(); + let event_mask_bytes = self.event_mask.serialize(); + let mut request0 = vec![ + SEND_EVENT_REQUEST, + propagate_bytes[0], + 0, + 0, + destination_bytes[0], + destination_bytes[1], + destination_bytes[2], + destination_bytes[3], + event_mask_bytes[0], + event_mask_bytes[1], + event_mask_bytes[2], + event_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.event[..]).len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.event[..]).into()], vec![])) + } +} +/// send an event. +/// +/// Identifies the `destination` window, determines which clients should receive +/// the specified event and ignores any active grabs. +/// +/// The `event` must be one of the core events or an event defined by an extension, +/// so that the X server can correctly byte-swap the contents as necessary. The +/// contents of `event` are otherwise unaltered and unchecked except for the +/// `send_event` field which is forced to 'true'. +/// +/// # Fields +/// +/// * `destination` - The window to send this event to. Every client which selects any event within +/// `event_mask` on `destination` will get the event. +/// +/// The special value `XCB_SEND_EVENT_DEST_POINTER_WINDOW` refers to the window +/// that contains the mouse pointer. +/// +/// The special value `XCB_SEND_EVENT_DEST_ITEM_FOCUS` refers to the window which +/// has the keyboard focus. +/// * `event_mask` - Event_mask for determining which clients should receive the specified event. +/// See `destination` and `propagate`. +/// * `propagate` - If `propagate` is true and no clients have selected any event on `destination`, +/// the destination is replaced with the closest ancestor of `destination` for +/// which some client has selected a type in `event_mask` and for which no +/// intervening window has that type in its do-not-propagate-mask. If no such +/// window exists or if the window is an ancestor of the focus window and +/// `InputFocus` was originally specified as the destination, the event is not sent +/// to any clients. Otherwise, the event is reported to every client selecting on +/// the final destination any of the types specified in `event_mask`. +/// * `event` - The event to send to the specified `destination`. +/// +/// # Errors +/// +/// * `Window` - The specified `destination` window does not exist. +/// * `Value` - The given `event` is neither a core event nor an event defined by an extension. +/// +/// # See +/// +/// * `ConfigureNotify`: event +/// +/// # Example +/// +/// ```text +/// /* +/// * Tell the given window that it was configured to a size of 800x600 pixels. +/// * +/// */ +/// void my_example(xcb_connection_t *conn, xcb_window_t window) { +/// /* Every X11 event is 32 bytes long. Therefore, XCB will copy 32 bytes. +/// * In order to properly initialize these bytes, we allocate 32 bytes even +/// * though we only need less for an xcb_configure_notify_event_t */ +/// xcb_configure_notify_event_t *event = calloc(32, 1); +/// +/// event->event = window; +/// event->window = window; +/// event->response_type = XCB_CONFIGURE_NOTIFY; +/// +/// event->x = 0; +/// event->y = 0; +/// event->width = 800; +/// event->height = 600; +/// +/// event->border_width = 0; +/// event->above_sibling = XCB_NONE; +/// event->override_redirect = false; +/// +/// xcb_send_event(conn, false, window, XCB_EVENT_MASK_STRUCTURE_NOTIFY, +/// (char*)event); +/// xcb_flush(conn); +/// free(event); +/// } +/// ``` pub fn send_event(conn: &Conn, propagate: bool, destination: A, event_mask: B, event: C) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -8781,30 +9991,16 @@ where let destination: Window = destination.into(); let event_mask: u32 = event_mask.into(); let event: [u8; 32] = event.into(); - let length_so_far = 0; - let propagate_bytes = propagate.serialize(); - let destination_bytes = destination.serialize(); - let event_mask_bytes = event_mask.serialize(); - let mut request0 = [ - SEND_EVENT_REQUEST, - propagate_bytes[0], - 0, - 0, - destination_bytes[0], - destination_bytes[1], - destination_bytes[2], - destination_bytes[3], - event_mask_bytes[0], - event_mask_bytes[1], - event_mask_bytes[2], - event_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + event.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&event)], vec![])?) + let event = &event; + let request0 = SendEventRequest { + propagate, + destination, + event_mask, + event, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// # Fields @@ -9086,6 +10282,137 @@ pub const GRAB_POINTER_REQUEST: u8 = 26; /// } /// } /// ``` +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GrabPointerRequest { + pub owner_events: bool, + pub grab_window: Window, + pub event_mask: u16, + pub pointer_mode: GrabMode, + pub keyboard_mode: GrabMode, + pub confine_to: Window, + pub cursor: Cursor, + pub time: Timestamp, +} +impl GrabPointerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let owner_events_bytes = self.owner_events.serialize(); + let grab_window_bytes = self.grab_window.serialize(); + let event_mask_bytes = self.event_mask.serialize(); + let pointer_mode_bytes = u8::from(self.pointer_mode).serialize(); + let keyboard_mode_bytes = u8::from(self.keyboard_mode).serialize(); + let confine_to_bytes = self.confine_to.serialize(); + let cursor_bytes = self.cursor.serialize(); + let time_bytes = self.time.serialize(); + let mut request0 = vec![ + GRAB_POINTER_REQUEST, + owner_events_bytes[0], + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + event_mask_bytes[0], + event_mask_bytes[1], + pointer_mode_bytes[0], + keyboard_mode_bytes[0], + confine_to_bytes[0], + confine_to_bytes[1], + confine_to_bytes[2], + confine_to_bytes[3], + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Grab the pointer. +/// +/// Actively grabs control of the pointer. Further pointer events are reported only to the grabbing client. Overrides any active pointer grab by this client. +/// +/// # Fields +/// +/// * `event_mask` - Specifies which pointer events are reported to the client. +/// +/// TODO: which values? +/// * `confine_to` - Specifies the window to confine the pointer in (the user will not be able to +/// move the pointer out of that window). +/// +/// The special value `XCB_NONE` means don't confine the pointer. +/// * `cursor` - Specifies the cursor that should be displayed or `XCB_NONE` to not change the +/// cursor. +/// * `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not +/// reported to the `grab_window`. +/// * `grab_window` - Specifies the window on which the pointer should be grabbed. +/// * `time` - The time argument allows you to avoid certain circumstances that come up if +/// applications take a long time to respond or if there are long network delays. +/// Consider a situation where you have two applications, both of which normally +/// grab the pointer when clicked on. If both applications specify the timestamp +/// from the event, the second application may wake up faster and successfully grab +/// the pointer before the first application. The first application then will get +/// an indication that the other application grabbed the pointer before its request +/// was processed. +/// +/// The special value `XCB_CURRENT_TIME` will be replaced with the current server +/// time. +/// * `pointer_mode` - +/// * `keyboard_mode` - +/// +/// # Errors +/// +/// * `Value` - TODO: reasons? +/// * `Window` - The specified `window` does not exist. +/// +/// # See +/// +/// * `GrabKeyboard`: request +/// +/// # Example +/// +/// ```text +/// /* +/// * Grabs the pointer actively +/// * +/// */ +/// void my_example(xcb_connection_t *conn, xcb_screen_t *screen, xcb_cursor_t cursor) { +/// xcb_grab_pointer_cookie_t cookie; +/// xcb_grab_pointer_reply_t *reply; +/// +/// cookie = xcb_grab_pointer( +/// conn, +/// false, /* get all pointer events specified by the following mask */ +/// screen->root, /* grab the root window */ +/// XCB_NONE, /* which events to let through */ +/// XCB_GRAB_MODE_ASYNC, /* pointer events should continue as normal */ +/// XCB_GRAB_MODE_ASYNC, /* keyboard mode */ +/// XCB_NONE, /* confine_to = in which window should the cursor stay */ +/// cursor, /* we change the cursor to whatever the user wanted */ +/// XCB_CURRENT_TIME +/// ); +/// +/// if ((reply = xcb_grab_pointer_reply(conn, cookie, NULL))) { +/// if (reply->status == XCB_GRAB_STATUS_SUCCESS) +/// printf("successfully grabbed the pointer\\n"); +/// free(preply); +/// } +/// } +/// ``` pub fn grab_pointer(conn: &Conn, owner_events: bool, grab_window: Window, event_mask: A, pointer_mode: GrabMode, keyboard_mode: GrabMode, confine_to: B, cursor: C, time: D) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -9098,46 +10425,19 @@ where let confine_to: Window = confine_to.into(); let cursor: Cursor = cursor.into(); let time: Timestamp = time.into(); - let length_so_far = 0; - let owner_events_bytes = owner_events.serialize(); - let grab_window_bytes = grab_window.serialize(); - let event_mask_bytes = event_mask.serialize(); - let pointer_mode_bytes = u8::from(pointer_mode).serialize(); - let keyboard_mode_bytes = u8::from(keyboard_mode).serialize(); - let confine_to_bytes = confine_to.serialize(); - let cursor_bytes = cursor.serialize(); - let time_bytes = time.serialize(); - let mut request0 = [ - GRAB_POINTER_REQUEST, - owner_events_bytes[0], - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - event_mask_bytes[0], - event_mask_bytes[1], - pointer_mode_bytes[0], - keyboard_mode_bytes[0], - confine_to_bytes[0], - confine_to_bytes[1], - confine_to_bytes[2], - confine_to_bytes[3], - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GrabPointerRequest { + owner_events, + grab_window, + event_mask, + pointer_mode, + keyboard_mode, + confine_to, + cursor, + time, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -9190,29 +10490,71 @@ pub const UNGRAB_POINTER_REQUEST: u8 = 27; /// * `GrabButton`: request /// * `EnterNotify`: event /// * `LeaveNotify`: event +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UngrabPointerRequest { + pub time: Timestamp, +} +impl UngrabPointerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let time_bytes = self.time.serialize(); + let mut request0 = vec![ + UNGRAB_POINTER_REQUEST, + 0, + 0, + 0, + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// release the pointer. +/// +/// Releases the pointer and any queued events if you actively grabbed the pointer +/// before using `xcb_grab_pointer`, `xcb_grab_button` or within a normal button +/// press. +/// +/// EnterNotify and LeaveNotify events are generated. +/// +/// # Fields +/// +/// * `time` - Timestamp to avoid race conditions when running X over the network. +/// +/// The pointer will not be released if `time` is earlier than the +/// last-pointer-grab time or later than the current X server time. +/// * `name_len` - Length (in bytes) of `name`. +/// * `name` - A pattern describing an X core font. +/// +/// # See +/// +/// * `GrabPointer`: request +/// * `GrabButton`: request +/// * `EnterNotify`: event +/// * `LeaveNotify`: event pub fn ungrab_pointer(conn: &Conn, time: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { let time: Timestamp = time.into(); - let length_so_far = 0; - let time_bytes = time.serialize(); - let mut request0 = [ - UNGRAB_POINTER_REQUEST, - 0, - 0, - 0, - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UngrabPointerRequest { + time, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// # Fields @@ -9366,10 +10708,139 @@ pub const GRAB_BUTTON_REQUEST: u8 = 28; /// * `Value` - TODO: reasons? /// * `Cursor` - The specified `cursor` does not exist. /// * `Window` - The specified `window` does not exist. -pub fn grab_button(conn: &Conn, owner_events: bool, grab_window: Window, event_mask: A, pointer_mode: GrabMode, keyboard_mode: GrabMode, confine_to: B, cursor: C, button: ButtonIndex, modifiers: D) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, - A: Into, +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GrabButtonRequest { + pub owner_events: bool, + pub grab_window: Window, + pub event_mask: u16, + pub pointer_mode: GrabMode, + pub keyboard_mode: GrabMode, + pub confine_to: Window, + pub cursor: Cursor, + pub button: ButtonIndex, + pub modifiers: u16, +} +impl GrabButtonRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let owner_events_bytes = self.owner_events.serialize(); + let grab_window_bytes = self.grab_window.serialize(); + let event_mask_bytes = self.event_mask.serialize(); + let pointer_mode_bytes = u8::from(self.pointer_mode).serialize(); + let keyboard_mode_bytes = u8::from(self.keyboard_mode).serialize(); + let confine_to_bytes = self.confine_to.serialize(); + let cursor_bytes = self.cursor.serialize(); + let button_bytes = u8::from(self.button).serialize(); + let modifiers_bytes = self.modifiers.serialize(); + let mut request0 = vec![ + GRAB_BUTTON_REQUEST, + owner_events_bytes[0], + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + event_mask_bytes[0], + event_mask_bytes[1], + pointer_mode_bytes[0], + keyboard_mode_bytes[0], + confine_to_bytes[0], + confine_to_bytes[1], + confine_to_bytes[2], + confine_to_bytes[3], + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + button_bytes[0], + 0, + modifiers_bytes[0], + modifiers_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Grab pointer button(s). +/// +/// This request establishes a passive grab. The pointer is actively grabbed as +/// described in GrabPointer, the last-pointer-grab time is set to the time at +/// which the button was pressed (as transmitted in the ButtonPress event), and the +/// ButtonPress event is reported if all of the following conditions are true: +/// +/// The pointer is not grabbed and the specified button is logically pressed when +/// the specified modifier keys are logically down, and no other buttons or +/// modifier keys are logically down. +/// +/// The grab-window contains the pointer. +/// +/// The confine-to window (if any) is viewable. +/// +/// A passive grab on the same button/key combination does not exist on any +/// ancestor of grab-window. +/// +/// The interpretation of the remaining arguments is the same as for GrabPointer. +/// The active grab is terminated automatically when the logical state of the +/// pointer has all buttons released, independent of the logical state of modifier +/// keys. Note that the logical state of a device (as seen by means of the +/// protocol) may lag the physical state if device event processing is frozen. This +/// request overrides all previous passive grabs by the same client on the same +/// button/key combinations on the same window. A modifier of AnyModifier is +/// equivalent to issuing the request for all possible modifier combinations +/// (including the combination of no modifiers). It is not required that all +/// specified modifiers have currently assigned keycodes. A button of AnyButton is +/// equivalent to issuing the request for all possible buttons. Otherwise, it is +/// not required that the button specified currently be assigned to a physical +/// button. +/// +/// An Access error is generated if some other client has already issued a +/// GrabButton request with the same button/key combination on the same window. +/// When using AnyModifier or AnyButton, the request fails completely (no grabs are +/// established), and an Access error is generated if there is a conflicting grab +/// for any combination. The request has no effect on an active grab. +/// +/// # Fields +/// +/// * `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not +/// reported to the `grab_window`. +/// * `grab_window` - Specifies the window on which the pointer should be grabbed. +/// * `event_mask` - Specifies which pointer events are reported to the client. +/// +/// TODO: which values? +/// * `confine_to` - Specifies the window to confine the pointer in (the user will not be able to +/// move the pointer out of that window). +/// +/// The special value `XCB_NONE` means don't confine the pointer. +/// * `cursor` - Specifies the cursor that should be displayed or `XCB_NONE` to not change the +/// cursor. +/// * `modifiers` - The modifiers to grab. +/// +/// Using the special value `XCB_MOD_MASK_ANY` means grab the pointer with all +/// possible modifier combinations. +/// * `pointer_mode` - +/// * `keyboard_mode` - +/// * `button` - +/// +/// # Errors +/// +/// * `Access` - Another client has already issued a GrabButton with the same button/key +/// combination on the same window. +/// * `Value` - TODO: reasons? +/// * `Cursor` - The specified `cursor` does not exist. +/// * `Window` - The specified `window` does not exist. +pub fn grab_button(conn: &Conn, owner_events: bool, grab_window: Window, event_mask: A, pointer_mode: GrabMode, keyboard_mode: GrabMode, confine_to: B, cursor: C, button: ButtonIndex, modifiers: D) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, + A: Into, B: Into, C: Into, D: Into, @@ -9378,84 +10849,122 @@ where let confine_to: Window = confine_to.into(); let cursor: Cursor = cursor.into(); let modifiers: u16 = modifiers.into(); - let length_so_far = 0; - let owner_events_bytes = owner_events.serialize(); - let grab_window_bytes = grab_window.serialize(); - let event_mask_bytes = event_mask.serialize(); - let pointer_mode_bytes = u8::from(pointer_mode).serialize(); - let keyboard_mode_bytes = u8::from(keyboard_mode).serialize(); - let confine_to_bytes = confine_to.serialize(); - let cursor_bytes = cursor.serialize(); - let button_bytes = u8::from(button).serialize(); - let modifiers_bytes = modifiers.serialize(); - let mut request0 = [ - GRAB_BUTTON_REQUEST, - owner_events_bytes[0], - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - event_mask_bytes[0], - event_mask_bytes[1], - pointer_mode_bytes[0], - keyboard_mode_bytes[0], - confine_to_bytes[0], - confine_to_bytes[1], - confine_to_bytes[2], - confine_to_bytes[3], - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - button_bytes[0], - 0, - modifiers_bytes[0], - modifiers_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GrabButtonRequest { + owner_events, + grab_window, + event_mask, + pointer_mode, + keyboard_mode, + confine_to, + cursor, + button, + modifiers, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UngrabButton request pub const UNGRAB_BUTTON_REQUEST: u8 = 29; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UngrabButtonRequest { + pub button: ButtonIndex, + pub grab_window: Window, + pub modifiers: u16, +} +impl UngrabButtonRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let button_bytes = u8::from(self.button).serialize(); + let grab_window_bytes = self.grab_window.serialize(); + let modifiers_bytes = self.modifiers.serialize(); + let mut request0 = vec![ + UNGRAB_BUTTON_REQUEST, + button_bytes[0], + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + modifiers_bytes[0], + modifiers_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn ungrab_button(conn: &Conn, button: ButtonIndex, grab_window: Window, modifiers: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { let modifiers: u16 = modifiers.into(); - let length_so_far = 0; - let button_bytes = u8::from(button).serialize(); - let grab_window_bytes = grab_window.serialize(); - let modifiers_bytes = modifiers.serialize(); - let mut request0 = [ - UNGRAB_BUTTON_REQUEST, - button_bytes[0], - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - modifiers_bytes[0], - modifiers_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UngrabButtonRequest { + button, + grab_window, + modifiers, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ChangeActivePointerGrab request pub const CHANGE_ACTIVE_POINTER_GRAB_REQUEST: u8 = 30; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangeActivePointerGrabRequest { + pub cursor: Cursor, + pub time: Timestamp, + pub event_mask: u16, +} +impl ChangeActivePointerGrabRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cursor_bytes = self.cursor.serialize(); + let time_bytes = self.time.serialize(); + let event_mask_bytes = self.event_mask.serialize(); + let mut request0 = vec![ + CHANGE_ACTIVE_POINTER_GRAB_REQUEST, + 0, + 0, + 0, + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + event_mask_bytes[0], + event_mask_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn change_active_pointer_grab(conn: &Conn, cursor: A, time: B, event_mask: C) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -9466,33 +10975,14 @@ where let cursor: Cursor = cursor.into(); let time: Timestamp = time.into(); let event_mask: u16 = event_mask.into(); - let length_so_far = 0; - let cursor_bytes = cursor.serialize(); - let time_bytes = time.serialize(); - let event_mask_bytes = event_mask.serialize(); - let mut request0 = [ - CHANGE_ACTIVE_POINTER_GRAB_REQUEST, - 0, - 0, - 0, - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - event_mask_bytes[0], - event_mask_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ChangeActivePointerGrabRequest { + cursor, + time, + event_mask, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GrabKeyboard request @@ -9559,41 +11049,130 @@ pub const GRAB_KEYBOARD_REQUEST: u8 = 31; /// } /// } /// ``` +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GrabKeyboardRequest { + pub owner_events: bool, + pub grab_window: Window, + pub time: Timestamp, + pub pointer_mode: GrabMode, + pub keyboard_mode: GrabMode, +} +impl GrabKeyboardRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let owner_events_bytes = self.owner_events.serialize(); + let grab_window_bytes = self.grab_window.serialize(); + let time_bytes = self.time.serialize(); + let pointer_mode_bytes = u8::from(self.pointer_mode).serialize(); + let keyboard_mode_bytes = u8::from(self.keyboard_mode).serialize(); + let mut request0 = vec![ + GRAB_KEYBOARD_REQUEST, + owner_events_bytes[0], + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + pointer_mode_bytes[0], + keyboard_mode_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Grab the keyboard. +/// +/// Actively grabs control of the keyboard and generates FocusIn and FocusOut +/// events. Further key events are reported only to the grabbing client. +/// +/// Any active keyboard grab by this client is overridden. If the keyboard is +/// actively grabbed by some other client, `AlreadyGrabbed` is returned. If +/// `grab_window` is not viewable, `GrabNotViewable` is returned. If the keyboard +/// is frozen by an active grab of another client, `GrabFrozen` is returned. If the +/// specified `time` is earlier than the last-keyboard-grab time or later than the +/// current X server time, `GrabInvalidTime` is returned. Otherwise, the +/// last-keyboard-grab time is set to the specified time. +/// +/// # Fields +/// +/// * `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not +/// reported to the `grab_window`. +/// * `grab_window` - Specifies the window on which the pointer should be grabbed. +/// * `time` - Timestamp to avoid race conditions when running X over the network. +/// +/// The special value `XCB_CURRENT_TIME` will be replaced with the current server +/// time. +/// * `pointer_mode` - +/// * `keyboard_mode` - +/// +/// # Errors +/// +/// * `Value` - TODO: reasons? +/// * `Window` - The specified `window` does not exist. +/// +/// # See +/// +/// * `GrabPointer`: request +/// +/// # Example +/// +/// ```text +/// /* +/// * Grabs the keyboard actively +/// * +/// */ +/// void my_example(xcb_connection_t *conn, xcb_screen_t *screen) { +/// xcb_grab_keyboard_cookie_t cookie; +/// xcb_grab_keyboard_reply_t *reply; +/// +/// cookie = xcb_grab_keyboard( +/// conn, +/// true, /* report events */ +/// screen->root, /* grab the root window */ +/// XCB_CURRENT_TIME, +/// XCB_GRAB_MODE_ASYNC, /* process events as normal, do not require sync */ +/// XCB_GRAB_MODE_ASYNC +/// ); +/// +/// if ((reply = xcb_grab_keyboard_reply(conn, cookie, NULL))) { +/// if (reply->status == XCB_GRAB_STATUS_SUCCESS) +/// printf("successfully grabbed the keyboard\\n"); +/// +/// free(reply); +/// } +/// } +/// ``` pub fn grab_keyboard(conn: &Conn, owner_events: bool, grab_window: Window, time: A, pointer_mode: GrabMode, keyboard_mode: GrabMode) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { let time: Timestamp = time.into(); - let length_so_far = 0; - let owner_events_bytes = owner_events.serialize(); - let grab_window_bytes = grab_window.serialize(); - let time_bytes = time.serialize(); - let pointer_mode_bytes = u8::from(pointer_mode).serialize(); - let keyboard_mode_bytes = u8::from(keyboard_mode).serialize(); - let mut request0 = [ - GRAB_KEYBOARD_REQUEST, - owner_events_bytes[0], - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - pointer_mode_bytes[0], - keyboard_mode_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GrabKeyboardRequest { + owner_events, + grab_window, + time, + pointer_mode, + keyboard_mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -9623,29 +11202,48 @@ impl TryFrom<&[u8]> for GrabKeyboardReply { /// Opcode for the UngrabKeyboard request pub const UNGRAB_KEYBOARD_REQUEST: u8 = 32; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UngrabKeyboardRequest { + pub time: Timestamp, +} +impl UngrabKeyboardRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let time_bytes = self.time.serialize(); + let mut request0 = vec![ + UNGRAB_KEYBOARD_REQUEST, + 0, + 0, + 0, + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn ungrab_keyboard(conn: &Conn, time: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { let time: Timestamp = time.into(); - let length_so_far = 0; - let time_bytes = time.serialize(); - let mut request0 = [ - UNGRAB_KEYBOARD_REQUEST, - 0, - 0, - 0, - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UngrabKeyboardRequest { + time, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -9769,72 +11367,224 @@ pub const GRAB_KEY_REQUEST: u8 = 33; /// # See /// /// * `GrabKeyboard`: request -pub fn grab_key(conn: &Conn, owner_events: bool, grab_window: Window, modifiers: A, key: B, pointer_mode: GrabMode, keyboard_mode: GrabMode) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, - A: Into, - B: Into, -{ - let modifiers: u16 = modifiers.into(); - let key: Keycode = key.into(); - let length_so_far = 0; - let owner_events_bytes = owner_events.serialize(); - let grab_window_bytes = grab_window.serialize(); - let modifiers_bytes = modifiers.serialize(); - let key_bytes = key.serialize(); - let pointer_mode_bytes = u8::from(pointer_mode).serialize(); - let keyboard_mode_bytes = u8::from(keyboard_mode).serialize(); - let mut request0 = [ - GRAB_KEY_REQUEST, - owner_events_bytes[0], - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - modifiers_bytes[0], - modifiers_bytes[1], - key_bytes[0], - pointer_mode_bytes[0], - keyboard_mode_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GrabKeyRequest { + pub owner_events: bool, + pub grab_window: Window, + pub modifiers: u16, + pub key: Keycode, + pub pointer_mode: GrabMode, + pub keyboard_mode: GrabMode, +} +impl GrabKeyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let owner_events_bytes = self.owner_events.serialize(); + let grab_window_bytes = self.grab_window.serialize(); + let modifiers_bytes = self.modifiers.serialize(); + let key_bytes = self.key.serialize(); + let pointer_mode_bytes = u8::from(self.pointer_mode).serialize(); + let keyboard_mode_bytes = u8::from(self.keyboard_mode).serialize(); + let mut request0 = vec![ + GRAB_KEY_REQUEST, + owner_events_bytes[0], + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + modifiers_bytes[0], + modifiers_bytes[1], + key_bytes[0], + pointer_mode_bytes[0], + keyboard_mode_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } } - -/// Opcode for the UngrabKey request -pub const UNGRAB_KEY_REQUEST: u8 = 34; -/// release a key combination. -/// -/// Releases the key combination on `grab_window` if you grabbed it using -/// `xcb_grab_key` before. +/// Grab keyboard key(s). /// -/// # Fields +/// Establishes a passive grab on the keyboard. In the future, the keyboard is +/// actively grabbed (as for `GrabKeyboard`), the last-keyboard-grab time is set to +/// the time at which the key was pressed (as transmitted in the KeyPress event), +/// and the KeyPress event is reported if all of the following conditions are true: /// -/// * `key` - The keycode of the specified key combination. +/// The keyboard is not grabbed and the specified key (which can itself be a +/// modifier key) is logically pressed when the specified modifier keys are +/// logically down, and no other modifier keys are logically down. /// -/// Using the special value `XCB_GRAB_ANY` means releasing all possible key codes. -/// * `grab_window` - The window on which the grabbed key combination will be released. -/// * `modifiers` - The modifiers of the specified key combination. +/// Either the grab_window is an ancestor of (or is) the focus window, or the +/// grab_window is a descendant of the focus window and contains the pointer. /// -/// Using the special value `XCB_MOD_MASK_ANY` means releasing the key combination -/// with every possible modifier combination. +/// A passive grab on the same key combination does not exist on any ancestor of +/// grab_window. /// -/// # Errors +/// The interpretation of the remaining arguments is as for XGrabKeyboard. The active grab is terminated +/// automatically when the logical state of the keyboard has the specified key released (independent of the +/// logical state of the modifier keys), at which point a KeyRelease event is reported to the grabbing window. /// -/// * `Window` - The specified `grab_window` does not exist. -/// * `Value` - TODO: reasons? +/// Note that the logical state of a device (as seen by client applications) may lag the physical state if +/// device event processing is frozen. /// -/// # See +/// A modifiers argument of AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers). It is not required that all modifiers specified +/// have currently assigned KeyCodes. A keycode argument of AnyKey is equivalent to issuing the request for +/// all possible KeyCodes. Otherwise, the specified keycode must be in the range specified by min_keycode +/// and max_keycode in the connection setup, or a BadValue error results. /// -/// * `GrabKey`: request +/// If some other client has issued a XGrabKey with the same key combination on the same window, a BadAccess +/// error results. When using AnyModifier or AnyKey, the request fails completely, and a BadAccess error +/// results (no grabs are established) if there is a conflicting grab for any combination. +/// +/// # Fields +/// +/// * `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not +/// reported to the `grab_window`. +/// * `grab_window` - Specifies the window on which the pointer should be grabbed. +/// * `key` - The keycode of the key to grab. +/// +/// The special value `XCB_GRAB_ANY` means grab any key. +/// * `cursor` - Specifies the cursor that should be displayed or `XCB_NONE` to not change the +/// cursor. +/// * `modifiers` - The modifiers to grab. +/// +/// Using the special value `XCB_MOD_MASK_ANY` means grab the pointer with all +/// possible modifier combinations. +/// * `pointer_mode` - +/// * `keyboard_mode` - +/// +/// # Errors +/// +/// * `Access` - Another client has already issued a GrabKey with the same button/key +/// combination on the same window. +/// * `Value` - TODO: reasons? +/// * `Window` - The specified `window` does not exist. +/// +/// # See +/// +/// * `GrabKeyboard`: request +pub fn grab_key(conn: &Conn, owner_events: bool, grab_window: Window, modifiers: A, key: B, pointer_mode: GrabMode, keyboard_mode: GrabMode) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, + A: Into, + B: Into, +{ + let modifiers: u16 = modifiers.into(); + let key: Keycode = key.into(); + let request0 = GrabKeyRequest { + owner_events, + grab_window, + modifiers, + key, + pointer_mode, + keyboard_mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) +} + +/// Opcode for the UngrabKey request +pub const UNGRAB_KEY_REQUEST: u8 = 34; +/// release a key combination. +/// +/// Releases the key combination on `grab_window` if you grabbed it using +/// `xcb_grab_key` before. +/// +/// # Fields +/// +/// * `key` - The keycode of the specified key combination. +/// +/// Using the special value `XCB_GRAB_ANY` means releasing all possible key codes. +/// * `grab_window` - The window on which the grabbed key combination will be released. +/// * `modifiers` - The modifiers of the specified key combination. +/// +/// Using the special value `XCB_MOD_MASK_ANY` means releasing the key combination +/// with every possible modifier combination. +/// +/// # Errors +/// +/// * `Window` - The specified `grab_window` does not exist. +/// * `Value` - TODO: reasons? +/// +/// # See +/// +/// * `GrabKey`: request +/// * `xev`: program +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UngrabKeyRequest { + pub key: Keycode, + pub grab_window: Window, + pub modifiers: u16, +} +impl UngrabKeyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let key_bytes = self.key.serialize(); + let grab_window_bytes = self.grab_window.serialize(); + let modifiers_bytes = self.modifiers.serialize(); + let mut request0 = vec![ + UNGRAB_KEY_REQUEST, + key_bytes[0], + 0, + 0, + grab_window_bytes[0], + grab_window_bytes[1], + grab_window_bytes[2], + grab_window_bytes[3], + modifiers_bytes[0], + modifiers_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// release a key combination. +/// +/// Releases the key combination on `grab_window` if you grabbed it using +/// `xcb_grab_key` before. +/// +/// # Fields +/// +/// * `key` - The keycode of the specified key combination. +/// +/// Using the special value `XCB_GRAB_ANY` means releasing all possible key codes. +/// * `grab_window` - The window on which the grabbed key combination will be released. +/// * `modifiers` - The modifiers of the specified key combination. +/// +/// Using the special value `XCB_MOD_MASK_ANY` means releasing the key combination +/// with every possible modifier combination. +/// +/// # Errors +/// +/// * `Window` - The specified `grab_window` does not exist. +/// * `Value` - TODO: reasons? +/// +/// # See +/// +/// * `GrabKey`: request /// * `xev`: program pub fn ungrab_key(conn: &Conn, key: A, grab_window: Window, modifiers: B) -> Result, ConnectionError> where @@ -9844,29 +11594,14 @@ where { let key: Keycode = key.into(); let modifiers: u16 = modifiers.into(); - let length_so_far = 0; - let key_bytes = key.serialize(); - let grab_window_bytes = grab_window.serialize(); - let modifiers_bytes = modifiers.serialize(); - let mut request0 = [ - UNGRAB_KEY_REQUEST, - key_bytes[0], - 0, - 0, - grab_window_bytes[0], - grab_window_bytes[1], - grab_window_bytes[2], - grab_window_bytes[3], - modifiers_bytes[0], - modifiers_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UngrabKeyRequest { + key, + grab_window, + modifiers, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// # Fields @@ -10028,70 +11763,139 @@ pub const ALLOW_EVENTS_REQUEST: u8 = 35; /// # Errors /// /// * `Value` - You specified an invalid `mode`. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AllowEventsRequest { + pub mode: Allow, + pub time: Timestamp, +} +impl AllowEventsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mode_bytes = u8::from(self.mode).serialize(); + let time_bytes = self.time.serialize(); + let mut request0 = vec![ + ALLOW_EVENTS_REQUEST, + mode_bytes[0], + 0, + 0, + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// release queued events. +/// +/// Releases queued events if the client has caused a device (pointer/keyboard) to +/// freeze due to grabbing it actively. This request has no effect if `time` is +/// earlier than the last-grab time of the most recent active grab for this client +/// or if `time` is later than the current X server time. +/// +/// # Fields +/// +/// * `mode` - +/// * `time` - Timestamp to avoid race conditions when running X over the network. +/// +/// The special value `XCB_CURRENT_TIME` will be replaced with the current server +/// time. +/// +/// # Errors +/// +/// * `Value` - You specified an invalid `mode`. pub fn allow_events(conn: &Conn, mode: Allow, time: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { let time: Timestamp = time.into(); - let length_so_far = 0; - let mode_bytes = u8::from(mode).serialize(); - let time_bytes = time.serialize(); - let mut request0 = [ - ALLOW_EVENTS_REQUEST, - mode_bytes[0], - 0, - 0, - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = AllowEventsRequest { + mode, + time, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GrabServer request pub const GRAB_SERVER_REQUEST: u8 = 36; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GrabServerRequest; +impl GrabServerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + GRAB_SERVER_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn grab_server(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - GRAB_SERVER_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GrabServerRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UngrabServer request pub const UNGRAB_SERVER_REQUEST: u8 = 37; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UngrabServerRequest; +impl UngrabServerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + UNGRAB_SERVER_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn ungrab_server(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - UNGRAB_SERVER_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UngrabServerRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the QueryPointer request @@ -10109,27 +11913,59 @@ pub const QUERY_POINTER_REQUEST: u8 = 38; /// # Errors /// /// * `Window` - The specified `window` does not exist. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryPointerRequest { + pub window: Window, +} +impl QueryPointerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + QUERY_POINTER_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// get pointer coordinates. +/// +/// Gets the root window the pointer is logically on and the pointer coordinates +/// relative to the root window's origin. +/// +/// # Fields +/// +/// * `window` - A window to check if the pointer is on the same screen as `window` (see the +/// `same_screen` field in the reply). +/// +/// # Errors +/// +/// * `Window` - The specified `window` does not exist. pub fn query_pointer(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - QUERY_POINTER_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryPointerRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } /// # Fields @@ -10238,6 +12074,48 @@ impl Serialize for Timecoord { /// Opcode for the GetMotionEvents request pub const GET_MOTION_EVENTS_REQUEST: u8 = 39; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetMotionEventsRequest { + pub window: Window, + pub start: Timestamp, + pub stop: Timestamp, +} +impl GetMotionEventsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let start_bytes = self.start.serialize(); + let stop_bytes = self.stop.serialize(); + let mut request0 = vec![ + GET_MOTION_EVENTS_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + start_bytes[0], + start_bytes[1], + start_bytes[2], + start_bytes[3], + stop_bytes[0], + stop_bytes[1], + stop_bytes[2], + stop_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_motion_events(conn: &Conn, window: Window, start: A, stop: B) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -10246,33 +12124,14 @@ where { let start: Timestamp = start.into(); let stop: Timestamp = stop.into(); - let length_so_far = 0; - let window_bytes = window.serialize(); - let start_bytes = start.serialize(); - let stop_bytes = stop.serialize(); - let mut request0 = [ - GET_MOTION_EVENTS_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - start_bytes[0], - start_bytes[1], - start_bytes[2], - start_bytes[3], - stop_bytes[0], - stop_bytes[1], - stop_bytes[2], - stop_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetMotionEventsRequest { + window, + start, + stop, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -10319,38 +12178,63 @@ impl GetMotionEventsReply { /// Opcode for the TranslateCoordinates request pub const TRANSLATE_COORDINATES_REQUEST: u8 = 40; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct TranslateCoordinatesRequest { + pub src_window: Window, + pub dst_window: Window, + pub src_x: i16, + pub src_y: i16, +} +impl TranslateCoordinatesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let src_window_bytes = self.src_window.serialize(); + let dst_window_bytes = self.dst_window.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let mut request0 = vec![ + TRANSLATE_COORDINATES_REQUEST, + 0, + 0, + 0, + src_window_bytes[0], + src_window_bytes[1], + src_window_bytes[2], + src_window_bytes[3], + dst_window_bytes[0], + dst_window_bytes[1], + dst_window_bytes[2], + dst_window_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn translate_coordinates(conn: &Conn, src_window: Window, dst_window: Window, src_x: i16, src_y: i16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let src_window_bytes = src_window.serialize(); - let dst_window_bytes = dst_window.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let mut request0 = [ - TRANSLATE_COORDINATES_REQUEST, - 0, - 0, - 0, - src_window_bytes[0], - src_window_bytes[1], - src_window_bytes[2], - src_window_bytes[3], - dst_window_bytes[0], - dst_window_bytes[1], - dst_window_bytes[2], - dst_window_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = TranslateCoordinatesRequest { + src_window, + dst_window, + src_x, + src_y, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -10417,6 +12301,98 @@ pub const WARP_POINTER_REQUEST: u8 = 41; /// # See /// /// * `SetInputFocus`: request +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct WarpPointerRequest { + pub src_window: Window, + pub dst_window: Window, + pub src_x: i16, + pub src_y: i16, + pub src_width: u16, + pub src_height: u16, + pub dst_x: i16, + pub dst_y: i16, +} +impl WarpPointerRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let src_window_bytes = self.src_window.serialize(); + let dst_window_bytes = self.dst_window.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let src_width_bytes = self.src_width.serialize(); + let src_height_bytes = self.src_height.serialize(); + let dst_x_bytes = self.dst_x.serialize(); + let dst_y_bytes = self.dst_y.serialize(); + let mut request0 = vec![ + WARP_POINTER_REQUEST, + 0, + 0, + 0, + src_window_bytes[0], + src_window_bytes[1], + src_window_bytes[2], + src_window_bytes[3], + dst_window_bytes[0], + dst_window_bytes[1], + dst_window_bytes[2], + dst_window_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + src_width_bytes[0], + src_width_bytes[1], + src_height_bytes[0], + src_height_bytes[1], + dst_x_bytes[0], + dst_x_bytes[1], + dst_y_bytes[0], + dst_y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// move mouse pointer. +/// +/// Moves the mouse pointer to the specified position. +/// +/// If `src_window` is not `XCB_NONE` (TODO), the move will only take place if the +/// pointer is inside `src_window` and within the rectangle specified by (`src_x`, +/// `src_y`, `src_width`, `src_height`). The rectangle coordinates are relative to +/// `src_window`. +/// +/// If `dst_window` is not `XCB_NONE` (TODO), the pointer will be moved to the +/// offsets (`dst_x`, `dst_y`) relative to `dst_window`. If `dst_window` is +/// `XCB_NONE` (TODO), the pointer will be moved by the offsets (`dst_x`, `dst_y`) +/// relative to the current position of the pointer. +/// +/// # Fields +/// +/// * `src_window` - If `src_window` is not `XCB_NONE` (TODO), the move will only take place if the +/// pointer is inside `src_window` and within the rectangle specified by (`src_x`, +/// `src_y`, `src_width`, `src_height`). The rectangle coordinates are relative to +/// `src_window`. +/// * `dst_window` - If `dst_window` is not `XCB_NONE` (TODO), the pointer will be moved to the +/// offsets (`dst_x`, `dst_y`) relative to `dst_window`. If `dst_window` is +/// `XCB_NONE` (TODO), the pointer will be moved by the offsets (`dst_x`, `dst_y`) +/// relative to the current position of the pointer. +/// +/// # Errors +/// +/// * `Window` - TODO: reasons? +/// +/// # See +/// +/// * `SetInputFocus`: request pub fn warp_pointer(conn: &Conn, src_window: A, dst_window: B, src_x: i16, src_y: i16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, @@ -10425,46 +12401,19 @@ where { let src_window: Window = src_window.into(); let dst_window: Window = dst_window.into(); - let length_so_far = 0; - let src_window_bytes = src_window.serialize(); - let dst_window_bytes = dst_window.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let src_width_bytes = src_width.serialize(); - let src_height_bytes = src_height.serialize(); - let dst_x_bytes = dst_x.serialize(); - let dst_y_bytes = dst_y.serialize(); - let mut request0 = [ - WARP_POINTER_REQUEST, - 0, - 0, - 0, - src_window_bytes[0], - src_window_bytes[1], - src_window_bytes[2], - src_window_bytes[3], - dst_window_bytes[0], - dst_window_bytes[1], - dst_window_bytes[2], - dst_window_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - src_width_bytes[0], - src_width_bytes[1], - src_height_bytes[0], - src_height_bytes[1], - dst_x_bytes[0], - dst_x_bytes[1], - dst_y_bytes[0], - dst_y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = WarpPointerRequest { + src_window, + dst_window, + src_x, + src_y, + src_width, + src_height, + dst_x, + dst_y, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// # Fields @@ -10581,57 +12530,130 @@ pub const SET_INPUT_FOCUS_REQUEST: u8 = 42; /// /// * `FocusIn`: event /// * `FocusOut`: event -pub fn set_input_focus(conn: &Conn, revert_to: InputFocus, focus: A, time: B) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, - A: Into, - B: Into, -{ - let focus: Window = focus.into(); - let time: Timestamp = time.into(); - let length_so_far = 0; - let revert_to_bytes = u8::from(revert_to).serialize(); - let focus_bytes = focus.serialize(); - let time_bytes = time.serialize(); - let mut request0 = [ - SET_INPUT_FOCUS_REQUEST, - revert_to_bytes[0], - 0, - 0, - focus_bytes[0], - focus_bytes[1], - focus_bytes[2], - focus_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetInputFocusRequest { + pub revert_to: InputFocus, + pub focus: Window, + pub time: Timestamp, +} +impl SetInputFocusRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let revert_to_bytes = u8::from(self.revert_to).serialize(); + let focus_bytes = self.focus.serialize(); + let time_bytes = self.time.serialize(); + let mut request0 = vec![ + SET_INPUT_FOCUS_REQUEST, + revert_to_bytes[0], + 0, + 0, + focus_bytes[0], + focus_bytes[1], + focus_bytes[2], + focus_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Sets input focus. +/// +/// Changes the input focus and the last-focus-change time. If the specified `time` +/// is earlier than the current last-focus-change time, the request is ignored (to +/// avoid race conditions when running X over the network). +/// +/// A FocusIn and FocusOut event is generated when focus is changed. +/// +/// # Fields +/// +/// * `focus` - The window to focus. All keyboard events will be reported to this window. The +/// window must be viewable (TODO), or a `xcb_match_error_t` occurs (TODO). +/// +/// If `focus` is `XCB_NONE` (TODO), all keyboard events are +/// discarded until a new focus window is set. +/// +/// If `focus` is `XCB_POINTER_ROOT` (TODO), focus is on the root window of the +/// screen on which the pointer is on currently. +/// * `time` - Timestamp to avoid race conditions when running X over the network. +/// +/// The special value `XCB_CURRENT_TIME` will be replaced with the current server +/// time. +/// * `revert_to` - Specifies what happens when the `focus` window becomes unviewable (if `focus` +/// is neither `XCB_NONE` nor `XCB_POINTER_ROOT`). +/// +/// # Errors +/// +/// * `Window` - The specified `focus` window does not exist. +/// * `Match` - The specified `focus` window is not viewable. +/// * `Value` - TODO: Reasons? +/// +/// # See +/// +/// * `FocusIn`: event +/// * `FocusOut`: event +pub fn set_input_focus(conn: &Conn, revert_to: InputFocus, focus: A, time: B) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, + A: Into, + B: Into, +{ + let focus: Window = focus.into(); + let time: Timestamp = time.into(); + let request0 = SetInputFocusRequest { + revert_to, + focus, + time, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetInputFocus request pub const GET_INPUT_FOCUS_REQUEST: u8 = 43; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetInputFocusRequest; +impl GetInputFocusRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + GET_INPUT_FOCUS_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_input_focus(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - GET_INPUT_FOCUS_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetInputFocusRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -10663,22 +12685,37 @@ impl TryFrom<&[u8]> for GetInputFocusReply { /// Opcode for the QueryKeymap request pub const QUERY_KEYMAP_REQUEST: u8 = 44; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryKeymapRequest; +impl QueryKeymapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + QUERY_KEYMAP_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_keymap(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - QUERY_KEYMAP_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryKeymapRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -10729,61 +12766,121 @@ pub const OPEN_FONT_REQUEST: u8 = 45; /// # See /// /// * `xcb_generate_id`: function -pub fn open_font<'c, Conn>(conn: &'c Conn, fid: Font, name: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct OpenFontRequest<'input> { + pub fid: Font, + pub name: &'input [u8], +} +impl<'input> OpenFontRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let fid_bytes = self.fid.serialize(); + let name_len = u16::try_from(self.name.len()).expect("`name` has too many elements"); + let name_len_bytes = name_len.serialize(); + let mut request0 = vec![ + OPEN_FONT_REQUEST, + 0, + 0, + 0, + fid_bytes[0], + fid_bytes[1], + fid_bytes[2], + fid_bytes[3], + name_len_bytes[0], + name_len_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) + } +} +/// opens a font. +/// +/// Opens any X core font matching the given `name` (for example "-misc-fixed-*"). +/// +/// Note that X core fonts are deprecated (but still supported) in favor of +/// client-side rendering using Xft. +/// +/// # Fields +/// +/// * `fid` - The ID with which you will refer to the font, created by `xcb_generate_id`. +/// * `name_len` - Length (in bytes) of `name`. +/// * `name` - A pattern describing an X core font. +/// +/// # Errors +/// +/// * `Name` - No font matches the given `name`. +/// +/// # See +/// +/// * `xcb_generate_id`: function +pub fn open_font<'c, 'input, Conn>(conn: &'c Conn, fid: Font, name: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let fid_bytes = fid.serialize(); - let name_len = u16::try_from(name.len()).expect("`name` has too many elements"); - let name_len_bytes = name_len.serialize(); - let mut request0 = [ - OPEN_FONT_REQUEST, - 0, - 0, - 0, - fid_bytes[0], - fid_bytes[1], - fid_bytes[2], - fid_bytes[3], - name_len_bytes[0], - name_len_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) + let request0 = OpenFontRequest { + fid, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CloseFont request pub const CLOSE_FONT_REQUEST: u8 = 46; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CloseFontRequest { + pub font: Font, +} +impl CloseFontRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let font_bytes = self.font.serialize(); + let mut request0 = vec![ + CLOSE_FONT_REQUEST, + 0, + 0, + 0, + font_bytes[0], + font_bytes[1], + font_bytes[2], + font_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn close_font(conn: &Conn, font: Font) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let font_bytes = font.serialize(); - let mut request0 = [ - CLOSE_FONT_REQUEST, - 0, - 0, - 0, - font_bytes[0], - font_bytes[1], - font_bytes[2], - font_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CloseFontRequest { + font, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -10969,27 +13066,53 @@ pub const QUERY_FONT_REQUEST: u8 = 47; /// # Fields /// /// * `font` - The fontable (Font or Graphics Context) to query. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryFontRequest { + pub font: Fontable, +} +impl QueryFontRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let font_bytes = self.font.serialize(); + let mut request0 = vec![ + QUERY_FONT_REQUEST, + 0, + 0, + 0, + font_bytes[0], + font_bytes[1], + font_bytes[2], + font_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// query font metrics. +/// +/// Queries information associated with the font. +/// +/// # Fields +/// +/// * `font` - The fontable (Font or Graphics Context) to query. pub fn query_font(conn: &Conn, font: Fontable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let font_bytes = font.serialize(); - let mut request0 = [ - QUERY_FONT_REQUEST, - 0, - 0, - 0, - font_bytes[0], - font_bytes[1], - font_bytes[2], - font_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryFontRequest { + font, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } /// # Fields @@ -11122,34 +13245,89 @@ pub const QUERY_TEXT_EXTENTS_REQUEST: u8 = 48; /// /// * `GContext` - The specified graphics context does not exist. /// * `Font` - The specified `font` does not exist. -pub fn query_text_extents<'c, Conn>(conn: &'c Conn, font: Fontable, string: &[Char2b]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct QueryTextExtentsRequest<'input> { + pub font: Fontable, + pub string: &'input [Char2b], +} +impl<'input> QueryTextExtentsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let string_len = u32::try_from(self.string.len()).unwrap(); + let length_so_far = 0; + let odd_length = (string_len & 1u32) != 0; + let odd_length_bytes = odd_length.serialize(); + let font_bytes = self.font.serialize(); + let mut request0 = vec![ + QUERY_TEXT_EXTENTS_REQUEST, + odd_length_bytes[0], + 0, + 0, + font_bytes[0], + font_bytes[1], + font_bytes[2], + font_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let string_bytes = self.string.serialize(); + let length_so_far = length_so_far + string_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), string_bytes.into(), padding0.into()], vec![])) + } +} +/// get text extents. +/// +/// Query text extents from the X11 server. This request returns the bounding box +/// of the specified 16-bit character string in the specified `font` or the font +/// contained in the specified graphics context. +/// +/// `font_ascent` is set to the maximum of the ascent metrics of all characters in +/// the string. `font_descent` is set to the maximum of the descent metrics. +/// `overall_width` is set to the sum of the character-width metrics of all +/// characters in the string. For each character in the string, let W be the sum of +/// the character-width metrics of all characters preceding it in the string. Let L +/// be the left-side-bearing metric of the character plus W. Let R be the +/// right-side-bearing metric of the character plus W. The lbearing member is set +/// to the minimum L of all characters in the string. The rbearing member is set to +/// the maximum R. +/// +/// For fonts defined with linear indexing rather than 2-byte matrix indexing, each +/// `xcb_char2b_t` structure is interpreted as a 16-bit number with byte1 as the +/// most significant byte. If the font has no defined default character, undefined +/// characters in the string are taken to have all zero metrics. +/// +/// Characters with all zero metrics are ignored. If the font has no defined +/// default_char, the undefined characters in the string are also ignored. +/// +/// # Fields +/// +/// * `font` - The `font` to calculate text extents in. You can also pass a graphics context. +/// * `string_len` - The number of characters in `string`. +/// * `string` - The text to get text extents for. +/// +/// # Errors +/// +/// * `GContext` - The specified graphics context does not exist. +/// * `Font` - The specified `font` does not exist. +pub fn query_text_extents<'c, 'input, Conn>(conn: &'c Conn, font: Fontable, string: &'input [Char2b]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let string_len = u32::try_from(string.len()).unwrap(); - let length_so_far = 0; - let odd_length = (string_len & 1u32) != 0; - let odd_length_bytes = odd_length.serialize(); - let font_bytes = font.serialize(); - let mut request0 = [ - QUERY_TEXT_EXTENTS_REQUEST, - odd_length_bytes[0], - 0, - 0, - font_bytes[0], - font_bytes[1], - font_bytes[2], - font_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let string_bytes = string.serialize(); - let length_so_far = length_so_far + string_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&string_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = QueryTextExtentsRequest { + font, + string, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -11254,32 +13432,66 @@ pub const LIST_FONTS_REQUEST: u8 = 49; /// (?) is a wildcard for a single character. Use of uppercase or lowercase does /// not matter. /// * `max_names` - The maximum number of fonts to be returned. -pub fn list_fonts<'c, Conn>(conn: &'c Conn, max_names: u16, pattern: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ListFontsRequest<'input> { + pub max_names: u16, + pub pattern: &'input [u8], +} +impl<'input> ListFontsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let max_names_bytes = self.max_names.serialize(); + let pattern_len = u16::try_from(self.pattern.len()).expect("`pattern` has too many elements"); + let pattern_len_bytes = pattern_len.serialize(); + let mut request0 = vec![ + LIST_FONTS_REQUEST, + 0, + 0, + 0, + max_names_bytes[0], + max_names_bytes[1], + pattern_len_bytes[0], + pattern_len_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.pattern[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.pattern[..]).into(), padding0.into()], vec![])) + } +} +/// get matching font names. +/// +/// Gets a list of available font names which match the given `pattern`. +/// +/// # Fields +/// +/// * `pattern_len` - The length (in bytes) of `pattern`. +/// * `pattern` - A font pattern, for example "-misc-fixed-*". +/// +/// The asterisk (*) is a wildcard for any number of characters. The question mark +/// (?) is a wildcard for a single character. Use of uppercase or lowercase does +/// not matter. +/// * `max_names` - The maximum number of fonts to be returned. +pub fn list_fonts<'c, 'input, Conn>(conn: &'c Conn, max_names: u16, pattern: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let max_names_bytes = max_names.serialize(); - let pattern_len = u16::try_from(pattern.len()).expect("`pattern` has too many elements"); - let pattern_len_bytes = pattern_len.serialize(); - let mut request0 = [ - LIST_FONTS_REQUEST, - 0, - 0, - 0, - max_names_bytes[0], - max_names_bytes[1], - pattern_len_bytes[0], - pattern_len_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + pattern.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(pattern), IoSlice::new(&padding0)], vec![])?) + let request0 = ListFontsRequest { + max_names, + pattern, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } /// # Fields @@ -11342,32 +13554,66 @@ pub const LIST_FONTS_WITH_INFO_REQUEST: u8 = 50; /// (?) is a wildcard for a single character. Use of uppercase or lowercase does /// not matter. /// * `max_names` - The maximum number of fonts to be returned. -pub fn list_fonts_with_info<'c, Conn>(conn: &'c Conn, max_names: u16, pattern: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ListFontsWithInfoRequest<'input> { + pub max_names: u16, + pub pattern: &'input [u8], +} +impl<'input> ListFontsWithInfoRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let max_names_bytes = self.max_names.serialize(); + let pattern_len = u16::try_from(self.pattern.len()).expect("`pattern` has too many elements"); + let pattern_len_bytes = pattern_len.serialize(); + let mut request0 = vec![ + LIST_FONTS_WITH_INFO_REQUEST, + 0, + 0, + 0, + max_names_bytes[0], + max_names_bytes[1], + pattern_len_bytes[0], + pattern_len_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.pattern[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.pattern[..]).into(), padding0.into()], vec![])) + } +} +/// get matching font names and information. +/// +/// Gets a list of available font names which match the given `pattern`. +/// +/// # Fields +/// +/// * `pattern_len` - The length (in bytes) of `pattern`. +/// * `pattern` - A font pattern, for example "-misc-fixed-*". +/// +/// The asterisk (*) is a wildcard for any number of characters. The question mark +/// (?) is a wildcard for a single character. Use of uppercase or lowercase does +/// not matter. +/// * `max_names` - The maximum number of fonts to be returned. +pub fn list_fonts_with_info<'c, 'input, Conn>(conn: &'c Conn, max_names: u16, pattern: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let max_names_bytes = max_names.serialize(); - let pattern_len = u16::try_from(pattern.len()).expect("`pattern` has too many elements"); - let pattern_len_bytes = pattern_len.serialize(); - let mut request0 = [ - LIST_FONTS_WITH_INFO_REQUEST, - 0, - 0, - 0, - max_names_bytes[0], - max_names_bytes[1], - pattern_len_bytes[0], - pattern_len_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + pattern.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(ListFontsWithInfoCookie::new(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(pattern), IoSlice::new(&padding0)], vec![])?)) + let request0 = ListFontsWithInfoRequest { + max_names, + pattern, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(ListFontsWithInfoCookie::new(conn.send_request_with_reply(&slices, fds)?)) } /// # Fields @@ -11472,52 +13718,86 @@ impl ListFontsWithInfoReply { /// Opcode for the SetFontPath request pub const SET_FONT_PATH_REQUEST: u8 = 51; -pub fn set_font_path<'c, Conn>(conn: &'c Conn, font: &[Str]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetFontPathRequest<'input> { + pub font: &'input [Str], +} +impl<'input> SetFontPathRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let font_qty = u16::try_from(self.font.len()).expect("`font` has too many elements"); + let font_qty_bytes = font_qty.serialize(); + let mut request0 = vec![ + SET_FONT_PATH_REQUEST, + 0, + 0, + 0, + font_qty_bytes[0], + font_qty_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let font_bytes = self.font.serialize(); + let length_so_far = length_so_far + font_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), font_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_font_path<'c, 'input, Conn>(conn: &'c Conn, font: &'input [Str]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let font_qty = u16::try_from(font.len()).expect("`font` has too many elements"); - let font_qty_bytes = font_qty.serialize(); - let mut request0 = [ - SET_FONT_PATH_REQUEST, - 0, - 0, - 0, - font_qty_bytes[0], - font_qty_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let font_bytes = font.serialize(); - let length_so_far = length_so_far + font_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&font_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetFontPathRequest { + font, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetFontPath request pub const GET_FONT_PATH_REQUEST: u8 = 52; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetFontPathRequest; +impl GetFontPathRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + GET_FONT_PATH_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_font_path(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - GET_FONT_PATH_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetFontPathRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -11587,48 +13867,140 @@ pub const CREATE_PIXMAP_REQUEST: u8 = 53; /// # See /// /// * `xcb_generate_id`: function -pub fn create_pixmap(conn: &Conn, depth: u8, pid: Pixmap, drawable: Drawable, width: u16, height: u16) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, -{ - let length_so_far = 0; - let depth_bytes = depth.serialize(); - let pid_bytes = pid.serialize(); - let drawable_bytes = drawable.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let mut request0 = [ - CREATE_PIXMAP_REQUEST, - depth_bytes[0], - 0, - 0, - pid_bytes[0], - pid_bytes[1], - pid_bytes[2], - pid_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreatePixmapRequest { + pub depth: u8, + pub pid: Pixmap, + pub drawable: Drawable, + pub width: u16, + pub height: u16, } - -/// Opcode for the FreePixmap request -pub const FREE_PIXMAP_REQUEST: u8 = 54; -/// Destroys a pixmap. -/// -/// Deletes the association between the pixmap ID and the pixmap. The pixmap -/// storage will be freed when there are no more references to it. -/// +impl CreatePixmapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let depth_bytes = self.depth.serialize(); + let pid_bytes = self.pid.serialize(); + let drawable_bytes = self.drawable.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let mut request0 = vec![ + CREATE_PIXMAP_REQUEST, + depth_bytes[0], + 0, + 0, + pid_bytes[0], + pid_bytes[1], + pid_bytes[2], + pid_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Creates a pixmap. +/// +/// Creates a pixmap. The pixmap can only be used on the same screen as `drawable` +/// is on and only with drawables of the same `depth`. +/// +/// # Fields +/// +/// * `depth` - TODO +/// * `pid` - The ID with which you will refer to the new pixmap, created by +/// `xcb_generate_id`. +/// * `drawable` - Drawable to get the screen from. +/// * `width` - The width of the new pixmap. +/// * `height` - The height of the new pixmap. +/// +/// # Errors +/// +/// * `Value` - TODO: reasons? +/// * `Drawable` - The specified `drawable` (Window or Pixmap) does not exist. +/// * `Alloc` - The X server could not allocate the requested resources (no memory?). +/// +/// # See +/// +/// * `xcb_generate_id`: function +pub fn create_pixmap(conn: &Conn, depth: u8, pid: Pixmap, drawable: Drawable, width: u16, height: u16) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, +{ + let request0 = CreatePixmapRequest { + depth, + pid, + drawable, + width, + height, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) +} + +/// Opcode for the FreePixmap request +pub const FREE_PIXMAP_REQUEST: u8 = 54; +/// Destroys a pixmap. +/// +/// Deletes the association between the pixmap ID and the pixmap. The pixmap +/// storage will be freed when there are no more references to it. +/// +/// # Fields +/// +/// * `pixmap` - The pixmap to destroy. +/// +/// # Errors +/// +/// * `Pixmap` - The specified pixmap does not exist. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FreePixmapRequest { + pub pixmap: Pixmap, +} +impl FreePixmapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let pixmap_bytes = self.pixmap.serialize(); + let mut request0 = vec![ + FREE_PIXMAP_REQUEST, + 0, + 0, + 0, + pixmap_bytes[0], + pixmap_bytes[1], + pixmap_bytes[2], + pixmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Destroys a pixmap. +/// +/// Deletes the association between the pixmap ID and the pixmap. The pixmap +/// storage will be freed when there are no more references to it. +/// /// # Fields /// /// * `pixmap` - The pixmap to destroy. @@ -11640,23 +14012,12 @@ pub fn free_pixmap(conn: &Conn, pixmap: Pixmap) -> Result>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// # Fields @@ -12435,8 +14796,6 @@ impl TryFrom for ArcMode { } } -/// Opcode for the CreateGC request -pub const CREATE_GC_REQUEST: u8 = 55; /// Auxiliary and optional information for the `create_gc` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct CreateGCAux { @@ -12740,6 +15099,78 @@ impl CreateGCAux { } } +/// Opcode for the CreateGC request +pub const CREATE_GC_REQUEST: u8 = 55; +/// Creates a graphics context. +/// +/// Creates a graphics context. The graphics context can be used with any drawable +/// that has the same root and depth as the specified drawable. +/// +/// # Fields +/// +/// * `cid` - The ID with which you will refer to the graphics context, created by +/// `xcb_generate_id`. +/// * `drawable` - Drawable to get the root/depth from. +/// +/// # Errors +/// +/// * `Drawable` - The specified `drawable` (Window or Pixmap) does not exist. +/// * `Match` - TODO: reasons? +/// * `Font` - TODO: reasons? +/// * `Pixmap` - TODO: reasons? +/// * `Value` - TODO: reasons? +/// * `Alloc` - The X server could not allocate the requested resources (no memory?). +/// +/// # See +/// +/// * `xcb_generate_id`: function +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateGCRequest<'input> { + pub cid: Gcontext, + pub drawable: Drawable, + pub value_list: &'input CreateGCAux, +} +impl<'input> CreateGCRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cid_bytes = self.cid.serialize(); + let drawable_bytes = self.drawable.serialize(); + let value_mask = u32::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + CREATE_GC_REQUEST, + 0, + 0, + 0, + cid_bytes[0], + cid_bytes[1], + cid_bytes[2], + cid_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) + } +} /// Creates a graphics context. /// /// Creates a graphics context. The graphics context can be used with any drawable @@ -12763,46 +15194,20 @@ impl CreateGCAux { /// # See /// /// * `xcb_generate_id`: function -pub fn create_gc<'c, Conn>(conn: &'c Conn, cid: Gcontext, drawable: Drawable, value_list: &CreateGCAux) -> Result, ConnectionError> +pub fn create_gc<'c, 'input, Conn>(conn: &'c Conn, cid: Gcontext, drawable: Drawable, value_list: &'input CreateGCAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cid_bytes = cid.serialize(); - let drawable_bytes = drawable.serialize(); - let value_mask = u32::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - CREATE_GC_REQUEST, - 0, - 0, - 0, - cid_bytes[0], - cid_bytes[1], - cid_bytes[2], - cid_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = CreateGCRequest { + cid, + drawable, + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } -/// Opcode for the ChangeGC request -pub const CHANGE_GC_REQUEST: u8 = 56; /// Auxiliary and optional information for the `change_gc` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct ChangeGCAux { @@ -13106,6 +15511,94 @@ impl ChangeGCAux { } } +/// Opcode for the ChangeGC request +pub const CHANGE_GC_REQUEST: u8 = 56; +/// change graphics context components. +/// +/// Changes the components specified by `value_mask` for the specified graphics context. +/// +/// # Fields +/// +/// * `gc` - The graphics context to change. +/// * `value_mask` - +/// * `value_list` - Values for each of the components specified in the bitmask `value_mask`. The +/// order has to correspond to the order of possible `value_mask` bits. See the +/// example. +/// +/// # Errors +/// +/// * `Font` - TODO: reasons? +/// * `GContext` - TODO: reasons? +/// * `Match` - TODO: reasons? +/// * `Pixmap` - TODO: reasons? +/// * `Value` - TODO: reasons? +/// * `Alloc` - The X server could not allocate the requested resources (no memory?). +/// +/// # Example +/// +/// ```text +/// /* +/// * Changes the foreground color component of the specified graphics context. +/// * +/// */ +/// void my_example(xcb_connection_t *conn, xcb_gcontext_t gc, uint32_t fg, uint32_t bg) { +/// /* C99 allows us to use a compact way of changing a single component: */ +/// xcb_change_gc(conn, gc, XCB_GC_FOREGROUND, (uint32_t[]){ fg }); +/// +/// /* The more explicit way. Beware that the order of values is important! */ +/// uint32_t mask = 0; +/// mask |= XCB_GC_FOREGROUND; +/// mask |= XCB_GC_BACKGROUND; +/// +/// uint32_t values[] = { +/// fg, +/// bg +/// }; +/// xcb_change_gc(conn, gc, mask, values); +/// xcb_flush(conn); +/// } +/// ``` +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangeGCRequest<'input> { + pub gc: Gcontext, + pub value_list: &'input ChangeGCAux, +} +impl<'input> ChangeGCRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let gc_bytes = self.gc.serialize(); + let value_mask = u32::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + CHANGE_GC_REQUEST, + 0, + 0, + 0, + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) + } +} /// change graphics context components. /// /// Changes the components specified by `value_mask` for the specified graphics context. @@ -13151,109 +15644,135 @@ impl ChangeGCAux { /// xcb_flush(conn); /// } /// ``` -pub fn change_gc<'c, Conn>(conn: &'c Conn, gc: Gcontext, value_list: &ChangeGCAux) -> Result, ConnectionError> +pub fn change_gc<'c, 'input, Conn>(conn: &'c Conn, gc: Gcontext, value_list: &'input ChangeGCAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let gc_bytes = gc.serialize(); - let value_mask = u32::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - CHANGE_GC_REQUEST, - 0, - 0, - 0, - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeGCRequest { + gc, + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CopyGC request pub const COPY_GC_REQUEST: u8 = 57; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CopyGCRequest { + pub src_gc: Gcontext, + pub dst_gc: Gcontext, + pub value_mask: u32, +} +impl CopyGCRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let src_gc_bytes = self.src_gc.serialize(); + let dst_gc_bytes = self.dst_gc.serialize(); + let value_mask_bytes = self.value_mask.serialize(); + let mut request0 = vec![ + COPY_GC_REQUEST, + 0, + 0, + 0, + src_gc_bytes[0], + src_gc_bytes[1], + src_gc_bytes[2], + src_gc_bytes[3], + dst_gc_bytes[0], + dst_gc_bytes[1], + dst_gc_bytes[2], + dst_gc_bytes[3], + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn copy_gc(conn: &Conn, src_gc: Gcontext, dst_gc: Gcontext, value_mask: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { let value_mask: u32 = value_mask.into(); - let length_so_far = 0; - let src_gc_bytes = src_gc.serialize(); - let dst_gc_bytes = dst_gc.serialize(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - COPY_GC_REQUEST, - 0, - 0, - 0, - src_gc_bytes[0], - src_gc_bytes[1], - src_gc_bytes[2], - src_gc_bytes[3], - dst_gc_bytes[0], - dst_gc_bytes[1], - dst_gc_bytes[2], - dst_gc_bytes[3], - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CopyGCRequest { + src_gc, + dst_gc, + value_mask, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SetDashes request pub const SET_DASHES_REQUEST: u8 = 58; -pub fn set_dashes<'c, Conn>(conn: &'c Conn, gc: Gcontext, dash_offset: u16, dashes: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetDashesRequest<'input> { + pub gc: Gcontext, + pub dash_offset: u16, + pub dashes: &'input [u8], +} +impl<'input> SetDashesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let gc_bytes = self.gc.serialize(); + let dash_offset_bytes = self.dash_offset.serialize(); + let dashes_len = u16::try_from(self.dashes.len()).expect("`dashes` has too many elements"); + let dashes_len_bytes = dashes_len.serialize(); + let mut request0 = vec![ + SET_DASHES_REQUEST, + 0, + 0, + 0, + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + dash_offset_bytes[0], + dash_offset_bytes[1], + dashes_len_bytes[0], + dashes_len_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.dashes[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.dashes[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_dashes<'c, 'input, Conn>(conn: &'c Conn, gc: Gcontext, dash_offset: u16, dashes: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let gc_bytes = gc.serialize(); - let dash_offset_bytes = dash_offset.serialize(); - let dashes_len = u16::try_from(dashes.len()).expect("`dashes` has too many elements"); - let dashes_len_bytes = dashes_len.serialize(); - let mut request0 = [ - SET_DASHES_REQUEST, - 0, - 0, - 0, - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - dash_offset_bytes[0], - dash_offset_bytes[1], - dashes_len_bytes[0], - dashes_len_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + dashes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(dashes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetDashesRequest { + gc, + dash_offset, + dashes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -13326,38 +15845,65 @@ impl TryFrom for ClipOrdering { /// Opcode for the SetClipRectangles request pub const SET_CLIP_RECTANGLES_REQUEST: u8 = 59; -pub fn set_clip_rectangles<'c, Conn>(conn: &'c Conn, ordering: ClipOrdering, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles: &[Rectangle]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetClipRectanglesRequest<'input> { + pub ordering: ClipOrdering, + pub gc: Gcontext, + pub clip_x_origin: i16, + pub clip_y_origin: i16, + pub rectangles: &'input [Rectangle], +} +impl<'input> SetClipRectanglesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let ordering_bytes = u8::from(self.ordering).serialize(); + let gc_bytes = self.gc.serialize(); + let clip_x_origin_bytes = self.clip_x_origin.serialize(); + let clip_y_origin_bytes = self.clip_y_origin.serialize(); + let mut request0 = vec![ + SET_CLIP_RECTANGLES_REQUEST, + ordering_bytes[0], + 0, + 0, + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + clip_x_origin_bytes[0], + clip_x_origin_bytes[1], + clip_y_origin_bytes[0], + clip_y_origin_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let rectangles_bytes = self.rectangles.serialize(); + let length_so_far = length_so_far + rectangles_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), rectangles_bytes.into(), padding0.into()], vec![])) + } +} +pub fn set_clip_rectangles<'c, 'input, Conn>(conn: &'c Conn, ordering: ClipOrdering, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles: &'input [Rectangle]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let ordering_bytes = u8::from(ordering).serialize(); - let gc_bytes = gc.serialize(); - let clip_x_origin_bytes = clip_x_origin.serialize(); - let clip_y_origin_bytes = clip_y_origin.serialize(); - let mut request0 = [ - SET_CLIP_RECTANGLES_REQUEST, - ordering_bytes[0], - 0, - 0, - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - clip_x_origin_bytes[0], - clip_x_origin_bytes[1], - clip_y_origin_bytes[0], - clip_y_origin_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let rectangles_bytes = rectangles.serialize(); - let length_so_far = length_so_far + rectangles_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&rectangles_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetClipRectanglesRequest { + ordering, + gc, + clip_x_origin, + clip_y_origin, + rectangles, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the FreeGC request @@ -13373,65 +15919,124 @@ pub const FREE_GC_REQUEST: u8 = 60; /// # Errors /// /// * `GContext` - The specified graphics context does not exist. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FreeGCRequest { + pub gc: Gcontext, +} +impl FreeGCRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let gc_bytes = self.gc.serialize(); + let mut request0 = vec![ + FREE_GC_REQUEST, + 0, + 0, + 0, + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Destroys a graphics context. +/// +/// Destroys the specified `gc` and all associated storage. +/// +/// # Fields +/// +/// * `gc` - The graphics context to destroy. +/// +/// # Errors +/// +/// * `GContext` - The specified graphics context does not exist. pub fn free_gc(conn: &Conn, gc: Gcontext) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let gc_bytes = gc.serialize(); - let mut request0 = [ - FREE_GC_REQUEST, - 0, - 0, - 0, - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FreeGCRequest { + gc, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ClearArea request pub const CLEAR_AREA_REQUEST: u8 = 61; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ClearAreaRequest { + pub exposures: bool, + pub window: Window, + pub x: i16, + pub y: i16, + pub width: u16, + pub height: u16, +} +impl ClearAreaRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let exposures_bytes = self.exposures.serialize(); + let window_bytes = self.window.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let mut request0 = vec![ + CLEAR_AREA_REQUEST, + exposures_bytes[0], + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn clear_area(conn: &Conn, exposures: bool, window: Window, x: i16, y: i16, width: u16, height: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let exposures_bytes = exposures.serialize(); - let window_bytes = window.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let mut request0 = [ - CLEAR_AREA_REQUEST, - exposures_bytes[0], - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ClearAreaRequest { + exposures, + window, + x, + y, + width, + height, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CopyArea request @@ -13457,113 +16062,206 @@ pub const COPY_AREA_REQUEST: u8 = 62; /// * `Drawable` - The specified `drawable` (Window or Pixmap) does not exist. /// * `GContext` - The specified graphics context does not exist. /// * `Match` - `src_drawable` has a different root or depth than `dst_drawable`. -pub fn copy_area(conn: &Conn, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, -{ - let length_so_far = 0; - let src_drawable_bytes = src_drawable.serialize(); - let dst_drawable_bytes = dst_drawable.serialize(); - let gc_bytes = gc.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let dst_x_bytes = dst_x.serialize(); - let dst_y_bytes = dst_y.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let mut request0 = [ - COPY_AREA_REQUEST, - 0, - 0, - 0, - src_drawable_bytes[0], - src_drawable_bytes[1], - src_drawable_bytes[2], - src_drawable_bytes[3], - dst_drawable_bytes[0], - dst_drawable_bytes[1], - dst_drawable_bytes[2], - dst_drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - dst_x_bytes[0], - dst_x_bytes[1], - dst_y_bytes[0], - dst_y_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) -} +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CopyAreaRequest { + pub src_drawable: Drawable, + pub dst_drawable: Drawable, + pub gc: Gcontext, + pub src_x: i16, + pub src_y: i16, + pub dst_x: i16, + pub dst_y: i16, + pub width: u16, + pub height: u16, +} +impl CopyAreaRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let src_drawable_bytes = self.src_drawable.serialize(); + let dst_drawable_bytes = self.dst_drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let dst_x_bytes = self.dst_x.serialize(); + let dst_y_bytes = self.dst_y.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let mut request0 = vec![ + COPY_AREA_REQUEST, + 0, + 0, + 0, + src_drawable_bytes[0], + src_drawable_bytes[1], + src_drawable_bytes[2], + src_drawable_bytes[3], + dst_drawable_bytes[0], + dst_drawable_bytes[1], + dst_drawable_bytes[2], + dst_drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + dst_x_bytes[0], + dst_x_bytes[1], + dst_y_bytes[0], + dst_y_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// copy areas. +/// +/// Copies the specified rectangle from `src_drawable` to `dst_drawable`. +/// +/// # Fields +/// +/// * `dst_drawable` - The destination drawable (Window or Pixmap). +/// * `src_drawable` - The source drawable (Window or Pixmap). +/// * `gc` - The graphics context to use. +/// * `src_x` - The source X coordinate. +/// * `src_y` - The source Y coordinate. +/// * `dst_x` - The destination X coordinate. +/// * `dst_y` - The destination Y coordinate. +/// * `width` - The width of the area to copy (in pixels). +/// * `height` - The height of the area to copy (in pixels). +/// +/// # Errors +/// +/// * `Drawable` - The specified `drawable` (Window or Pixmap) does not exist. +/// * `GContext` - The specified graphics context does not exist. +/// * `Match` - `src_drawable` has a different root or depth than `dst_drawable`. +pub fn copy_area(conn: &Conn, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, +{ + let request0 = CopyAreaRequest { + src_drawable, + dst_drawable, + gc, + src_x, + src_y, + dst_x, + dst_y, + width, + height, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) +} /// Opcode for the CopyPlane request pub const COPY_PLANE_REQUEST: u8 = 63; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CopyPlaneRequest { + pub src_drawable: Drawable, + pub dst_drawable: Drawable, + pub gc: Gcontext, + pub src_x: i16, + pub src_y: i16, + pub dst_x: i16, + pub dst_y: i16, + pub width: u16, + pub height: u16, + pub bit_plane: u32, +} +impl CopyPlaneRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let src_drawable_bytes = self.src_drawable.serialize(); + let dst_drawable_bytes = self.dst_drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let dst_x_bytes = self.dst_x.serialize(); + let dst_y_bytes = self.dst_y.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let bit_plane_bytes = self.bit_plane.serialize(); + let mut request0 = vec![ + COPY_PLANE_REQUEST, + 0, + 0, + 0, + src_drawable_bytes[0], + src_drawable_bytes[1], + src_drawable_bytes[2], + src_drawable_bytes[3], + dst_drawable_bytes[0], + dst_drawable_bytes[1], + dst_drawable_bytes[2], + dst_drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + dst_x_bytes[0], + dst_x_bytes[1], + dst_y_bytes[0], + dst_y_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + bit_plane_bytes[0], + bit_plane_bytes[1], + bit_plane_bytes[2], + bit_plane_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn copy_plane(conn: &Conn, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, bit_plane: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let src_drawable_bytes = src_drawable.serialize(); - let dst_drawable_bytes = dst_drawable.serialize(); - let gc_bytes = gc.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let dst_x_bytes = dst_x.serialize(); - let dst_y_bytes = dst_y.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let bit_plane_bytes = bit_plane.serialize(); - let mut request0 = [ - COPY_PLANE_REQUEST, - 0, - 0, - 0, - src_drawable_bytes[0], - src_drawable_bytes[1], - src_drawable_bytes[2], - src_drawable_bytes[3], - dst_drawable_bytes[0], - dst_drawable_bytes[1], - dst_drawable_bytes[2], - dst_drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - dst_x_bytes[0], - dst_x_bytes[1], - dst_y_bytes[0], - dst_y_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - bit_plane_bytes[0], - bit_plane_bytes[1], - bit_plane_bytes[2], - bit_plane_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CopyPlaneRequest { + src_drawable, + dst_drawable, + gc, + src_x, + src_y, + dst_x, + dst_y, + width, + height, + bit_plane, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// # Fields @@ -13642,37 +16340,62 @@ impl TryFrom for CoordMode { /// Opcode for the PolyPoint request pub const POLY_POINT_REQUEST: u8 = 64; -pub fn poly_point<'c, Conn>(conn: &'c Conn, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &[Point]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolyPointRequest<'input> { + pub coordinate_mode: CoordMode, + pub drawable: Drawable, + pub gc: Gcontext, + pub points: &'input [Point], +} +impl<'input> PolyPointRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let coordinate_mode_bytes = u8::from(self.coordinate_mode).serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let mut request0 = vec![ + POLY_POINT_REQUEST, + coordinate_mode_bytes[0], + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let points_bytes = self.points.serialize(); + let length_so_far = length_so_far + points_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), points_bytes.into(), padding0.into()], vec![])) + } +} +pub fn poly_point<'c, 'input, Conn>(conn: &'c Conn, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &'input [Point]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let coordinate_mode_bytes = u8::from(coordinate_mode).serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let mut request0 = [ - POLY_POINT_REQUEST, - coordinate_mode_bytes[0], - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let points_bytes = points.serialize(); - let length_so_far = length_so_far + points_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&points_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = PolyPointRequest { + coordinate_mode, + drawable, + gc, + points, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PolyLine request @@ -13716,37 +16439,101 @@ pub const POLY_LINE_REQUEST: u8 = 65; /// xcb_flush(conn); /// } /// ``` -pub fn poly_line<'c, Conn>(conn: &'c Conn, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &[Point]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolyLineRequest<'input> { + pub coordinate_mode: CoordMode, + pub drawable: Drawable, + pub gc: Gcontext, + pub points: &'input [Point], +} +impl<'input> PolyLineRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let coordinate_mode_bytes = u8::from(self.coordinate_mode).serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let mut request0 = vec![ + POLY_LINE_REQUEST, + coordinate_mode_bytes[0], + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let points_bytes = self.points.serialize(); + let length_so_far = length_so_far + points_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), points_bytes.into(), padding0.into()], vec![])) + } +} +/// draw lines. +/// +/// Draws `points_len`-1 lines between each pair of points (point[i], point[i+1]) +/// in the `points` array. The lines are drawn in the order listed in the array. +/// They join correctly at all intermediate points, and if the first and last +/// points coincide, the first and last lines also join correctly. For any given +/// line, a pixel is not drawn more than once. If thin (zero line-width) lines +/// intersect, the intersecting pixels are drawn multiple times. If wide lines +/// intersect, the intersecting pixels are drawn only once, as though the entire +/// request were a single, filled shape. +/// +/// # Fields +/// +/// * `drawable` - The drawable to draw the line(s) on. +/// * `gc` - The graphics context to use. +/// * `points_len` - The number of `xcb_point_t` structures in `points`. +/// * `points` - An array of points. +/// * `coordinate_mode` - +/// +/// # Errors +/// +/// * `Drawable` - TODO: reasons? +/// * `GContext` - TODO: reasons? +/// * `Match` - TODO: reasons? +/// * `Value` - TODO: reasons? +/// +/// # Example +/// +/// ```text +/// /* +/// * Draw a straight line. +/// * +/// */ +/// void my_example(xcb_connection_t *conn, xcb_drawable_t drawable, xcb_gcontext_t gc) { +/// xcb_poly_line(conn, XCB_COORD_MODE_ORIGIN, drawable, gc, 2, +/// (xcb_point_t[]) { {10, 10}, {100, 10} }); +/// xcb_flush(conn); +/// } +/// ``` +pub fn poly_line<'c, 'input, Conn>(conn: &'c Conn, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &'input [Point]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let coordinate_mode_bytes = u8::from(coordinate_mode).serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let mut request0 = [ - POLY_LINE_REQUEST, - coordinate_mode_bytes[0], - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let points_bytes = points.serialize(); - let length_so_far = length_so_far + points_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&points_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = PolyLineRequest { + coordinate_mode, + drawable, + gc, + points, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -13827,104 +16614,199 @@ pub const POLY_SEGMENT_REQUEST: u8 = 66; /// * `Drawable` - The specified `drawable` does not exist. /// * `GContext` - The specified `gc` does not exist. /// * `Match` - TODO: reasons? -pub fn poly_segment<'c, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, segments: &[Segment]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolySegmentRequest<'input> { + pub drawable: Drawable, + pub gc: Gcontext, + pub segments: &'input [Segment], +} +impl<'input> PolySegmentRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let mut request0 = vec![ + POLY_SEGMENT_REQUEST, + 0, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let segments_bytes = self.segments.serialize(); + let length_so_far = length_so_far + segments_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), segments_bytes.into(), padding0.into()], vec![])) + } +} +/// draw lines. +/// +/// Draws multiple, unconnected lines. For each segment, a line is drawn between +/// (x1, y1) and (x2, y2). The lines are drawn in the order listed in the array of +/// `xcb_segment_t` structures and does not perform joining at coincident +/// endpoints. For any given line, a pixel is not drawn more than once. If lines +/// intersect, the intersecting pixels are drawn multiple times. +/// +/// TODO: include the xcb_segment_t data structure +/// +/// TODO: an example +/// +/// # Fields +/// +/// * `drawable` - A drawable (Window or Pixmap) to draw on. +/// * `gc` - The graphics context to use. +/// +/// TODO: document which attributes of a gc are used +/// * `segments_len` - The number of `xcb_segment_t` structures in `segments`. +/// * `segments` - An array of `xcb_segment_t` structures. +/// +/// # Errors +/// +/// * `Drawable` - The specified `drawable` does not exist. +/// * `GContext` - The specified `gc` does not exist. +/// * `Match` - TODO: reasons? +pub fn poly_segment<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, segments: &'input [Segment]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let mut request0 = [ - POLY_SEGMENT_REQUEST, - 0, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let segments_bytes = segments.serialize(); - let length_so_far = length_so_far + segments_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&segments_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = PolySegmentRequest { + drawable, + gc, + segments, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PolyRectangle request pub const POLY_RECTANGLE_REQUEST: u8 = 67; -pub fn poly_rectangle<'c, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, rectangles: &[Rectangle]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolyRectangleRequest<'input> { + pub drawable: Drawable, + pub gc: Gcontext, + pub rectangles: &'input [Rectangle], +} +impl<'input> PolyRectangleRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let mut request0 = vec![ + POLY_RECTANGLE_REQUEST, + 0, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let rectangles_bytes = self.rectangles.serialize(); + let length_so_far = length_so_far + rectangles_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), rectangles_bytes.into(), padding0.into()], vec![])) + } +} +pub fn poly_rectangle<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, rectangles: &'input [Rectangle]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let mut request0 = [ - POLY_RECTANGLE_REQUEST, - 0, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let rectangles_bytes = rectangles.serialize(); - let length_so_far = length_so_far + rectangles_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&rectangles_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = PolyRectangleRequest { + drawable, + gc, + rectangles, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PolyArc request pub const POLY_ARC_REQUEST: u8 = 68; -pub fn poly_arc<'c, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, arcs: &[Arc]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolyArcRequest<'input> { + pub drawable: Drawable, + pub gc: Gcontext, + pub arcs: &'input [Arc], +} +impl<'input> PolyArcRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let mut request0 = vec![ + POLY_ARC_REQUEST, + 0, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let arcs_bytes = self.arcs.serialize(); + let length_so_far = length_so_far + arcs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), arcs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn poly_arc<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, arcs: &'input [Arc]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let mut request0 = [ - POLY_ARC_REQUEST, - 0, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let arcs_bytes = arcs.serialize(); - let length_so_far = length_so_far + arcs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&arcs_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = PolyArcRequest { + drawable, + gc, + arcs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -13994,42 +16876,69 @@ impl TryFrom for PolyShape { /// Opcode for the FillPoly request pub const FILL_POLY_REQUEST: u8 = 69; -pub fn fill_poly<'c, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, shape: PolyShape, coordinate_mode: CoordMode, points: &[Point]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FillPolyRequest<'input> { + pub drawable: Drawable, + pub gc: Gcontext, + pub shape: PolyShape, + pub coordinate_mode: CoordMode, + pub points: &'input [Point], +} +impl<'input> FillPolyRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let shape_bytes = u8::from(self.shape).serialize(); + let coordinate_mode_bytes = u8::from(self.coordinate_mode).serialize(); + let mut request0 = vec![ + FILL_POLY_REQUEST, + 0, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + shape_bytes[0], + coordinate_mode_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let points_bytes = self.points.serialize(); + let length_so_far = length_so_far + points_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), points_bytes.into(), padding0.into()], vec![])) + } +} +pub fn fill_poly<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, shape: PolyShape, coordinate_mode: CoordMode, points: &'input [Point]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let shape_bytes = u8::from(shape).serialize(); - let coordinate_mode_bytes = u8::from(coordinate_mode).serialize(); - let mut request0 = [ - FILL_POLY_REQUEST, - 0, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - shape_bytes[0], - coordinate_mode_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let points_bytes = points.serialize(); - let length_so_far = length_so_far + points_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&points_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = FillPolyRequest { + drawable, + gc, + shape, + coordinate_mode, + points, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PolyFillRectangle request @@ -14059,76 +16968,147 @@ pub const POLY_FILL_RECTANGLE_REQUEST: u8 = 70; /// * `Drawable` - The specified `drawable` (Window or Pixmap) does not exist. /// * `GContext` - The specified graphics context does not exist. /// * `Match` - TODO: reasons? -pub fn poly_fill_rectangle<'c, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, rectangles: &[Rectangle]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolyFillRectangleRequest<'input> { + pub drawable: Drawable, + pub gc: Gcontext, + pub rectangles: &'input [Rectangle], +} +impl<'input> PolyFillRectangleRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let mut request0 = vec![ + POLY_FILL_RECTANGLE_REQUEST, + 0, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let rectangles_bytes = self.rectangles.serialize(); + let length_so_far = length_so_far + rectangles_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), rectangles_bytes.into(), padding0.into()], vec![])) + } +} +/// Fills rectangles. +/// +/// Fills the specified rectangle(s) in the order listed in the array. For any +/// given rectangle, each pixel is not drawn more than once. If rectangles +/// intersect, the intersecting pixels are drawn multiple times. +/// +/// # Fields +/// +/// * `drawable` - The drawable (Window or Pixmap) to draw on. +/// * `gc` - The graphics context to use. +/// +/// The following graphics context components are used: function, plane-mask, +/// fill-style, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask. +/// +/// The following graphics context mode-dependent components are used: +/// foreground, background, tile, stipple, tile-stipple-x-origin, and +/// tile-stipple-y-origin. +/// * `rectangles_len` - The number of `xcb_rectangle_t` structures in `rectangles`. +/// * `rectangles` - The rectangles to fill. +/// +/// # Errors +/// +/// * `Drawable` - The specified `drawable` (Window or Pixmap) does not exist. +/// * `GContext` - The specified graphics context does not exist. +/// * `Match` - TODO: reasons? +pub fn poly_fill_rectangle<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, rectangles: &'input [Rectangle]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let mut request0 = [ - POLY_FILL_RECTANGLE_REQUEST, - 0, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let rectangles_bytes = rectangles.serialize(); - let length_so_far = length_so_far + rectangles_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&rectangles_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = PolyFillRectangleRequest { + drawable, + gc, + rectangles, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PolyFillArc request pub const POLY_FILL_ARC_REQUEST: u8 = 71; -pub fn poly_fill_arc<'c, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, arcs: &[Arc]) -> Result, ConnectionError> -where - Conn: RequestConnection + ?Sized, -{ - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let mut request0 = [ - POLY_FILL_ARC_REQUEST, - 0, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let arcs_bytes = arcs.serialize(); - let length_so_far = length_so_far + arcs_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&arcs_bytes), IoSlice::new(&padding0)], vec![])?) +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolyFillArcRequest<'input> { + pub drawable: Drawable, + pub gc: Gcontext, + pub arcs: &'input [Arc], } - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -#[repr(u8)] -pub enum ImageFormat { - XYBitmap = 0, +impl<'input> PolyFillArcRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let mut request0 = vec![ + POLY_FILL_ARC_REQUEST, + 0, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let arcs_bytes = self.arcs.serialize(); + let length_so_far = length_so_far + arcs_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), arcs_bytes.into(), padding0.into()], vec![])) + } +} +pub fn poly_fill_arc<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, arcs: &'input [Arc]) -> Result, ConnectionError> +where + Conn: RequestConnection + ?Sized, +{ + let request0 = PolyFillArcRequest { + drawable, + gc, + arcs, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[repr(u8)] +pub enum ImageFormat { + XYBitmap = 0, XYPixmap = 1, ZPixmap = 2, } @@ -14192,97 +17172,165 @@ impl TryFrom for ImageFormat { /// Opcode for the PutImage request pub const PUT_IMAGE_REQUEST: u8 = 72; -pub fn put_image<'c, Conn>(conn: &'c Conn, format: ImageFormat, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PutImageRequest<'input> { + pub format: ImageFormat, + pub drawable: Drawable, + pub gc: Gcontext, + pub width: u16, + pub height: u16, + pub dst_x: i16, + pub dst_y: i16, + pub left_pad: u8, + pub depth: u8, + pub data: &'input [u8], +} +impl<'input> PutImageRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let format_bytes = u8::from(self.format).serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let dst_x_bytes = self.dst_x.serialize(); + let dst_y_bytes = self.dst_y.serialize(); + let left_pad_bytes = self.left_pad.serialize(); + let depth_bytes = self.depth.serialize(); + let mut request0 = vec![ + PUT_IMAGE_REQUEST, + format_bytes[0], + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + dst_x_bytes[0], + dst_x_bytes[1], + dst_y_bytes[0], + dst_y_bytes[1], + left_pad_bytes[0], + depth_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.data[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.data[..]).into(), padding0.into()], vec![])) + } +} +pub fn put_image<'c, 'input, Conn>(conn: &'c Conn, format: ImageFormat, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let format_bytes = u8::from(format).serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let dst_x_bytes = dst_x.serialize(); - let dst_y_bytes = dst_y.serialize(); - let left_pad_bytes = left_pad.serialize(); - let depth_bytes = depth.serialize(); - let mut request0 = [ - PUT_IMAGE_REQUEST, - format_bytes[0], - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - dst_x_bytes[0], - dst_x_bytes[1], - dst_y_bytes[0], - dst_y_bytes[1], - left_pad_bytes[0], - depth_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + data.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(data), IoSlice::new(&padding0)], vec![])?) + let request0 = PutImageRequest { + format, + drawable, + gc, + width, + height, + dst_x, + dst_y, + left_pad, + depth, + data, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetImage request pub const GET_IMAGE_REQUEST: u8 = 73; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetImageRequest { + pub format: ImageFormat, + pub drawable: Drawable, + pub x: i16, + pub y: i16, + pub width: u16, + pub height: u16, + pub plane_mask: u32, +} +impl GetImageRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let format_bytes = u8::from(self.format).serialize(); + let drawable_bytes = self.drawable.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let plane_mask_bytes = self.plane_mask.serialize(); + let mut request0 = vec![ + GET_IMAGE_REQUEST, + format_bytes[0], + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + plane_mask_bytes[0], + plane_mask_bytes[1], + plane_mask_bytes[2], + plane_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_image(conn: &Conn, format: ImageFormat, drawable: Drawable, x: i16, y: i16, width: u16, height: u16, plane_mask: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let format_bytes = u8::from(format).serialize(); - let drawable_bytes = drawable.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let plane_mask_bytes = plane_mask.serialize(); - let mut request0 = [ - GET_IMAGE_REQUEST, - format_bytes[0], - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - plane_mask_bytes[0], - plane_mask_bytes[1], - plane_mask_bytes[2], - plane_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetImageRequest { + format, + drawable, + x, + y, + width, + height, + plane_mask, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -14332,80 +17380,134 @@ impl GetImageReply { /// Opcode for the PolyText8 request pub const POLY_TEXT8_REQUEST: u8 = 74; -pub fn poly_text8<'c, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolyText8Request<'input> { + pub drawable: Drawable, + pub gc: Gcontext, + pub x: i16, + pub y: i16, + pub items: &'input [u8], +} +impl<'input> PolyText8Request<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let mut request0 = vec![ + POLY_TEXT8_REQUEST, + 0, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.items[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.items[..]).into(), padding0.into()], vec![])) + } +} +pub fn poly_text8<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let mut request0 = [ - POLY_TEXT8_REQUEST, - 0, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + items.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(items), IoSlice::new(&padding0)], vec![])?) + let request0 = PolyText8Request { + drawable, + gc, + x, + y, + items, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PolyText16 request pub const POLY_TEXT16_REQUEST: u8 = 75; -pub fn poly_text16<'c, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolyText16Request<'input> { + pub drawable: Drawable, + pub gc: Gcontext, + pub x: i16, + pub y: i16, + pub items: &'input [u8], +} +impl<'input> PolyText16Request<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let mut request0 = vec![ + POLY_TEXT16_REQUEST, + 0, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.items[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.items[..]).into(), padding0.into()], vec![])) + } +} +pub fn poly_text16<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let mut request0 = [ - POLY_TEXT16_REQUEST, - 0, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + items.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(items), IoSlice::new(&padding0)], vec![])?) + let request0 = PolyText16Request { + drawable, + gc, + x, + y, + items, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ImageText8 request @@ -14444,43 +17546,104 @@ pub const IMAGE_TEXT8_REQUEST: u8 = 76; /// # See /// /// * `ImageText16`: request -pub fn image_text8<'c, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ImageText8Request<'input> { + pub drawable: Drawable, + pub gc: Gcontext, + pub x: i16, + pub y: i16, + pub string: &'input [u8], +} +impl<'input> ImageText8Request<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let string_len = u8::try_from(self.string.len()).expect("`string` has too many elements"); + let string_len_bytes = string_len.serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let mut request0 = vec![ + IMAGE_TEXT8_REQUEST, + string_len_bytes[0], + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.string[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.string[..]).into(), padding0.into()], vec![])) + } +} +/// Draws text. +/// +/// Fills the destination rectangle with the background pixel from `gc`, then +/// paints the text with the foreground pixel from `gc`. The upper-left corner of +/// the filled rectangle is at [x, y - font-ascent]. The width is overall-width, +/// the height is font-ascent + font-descent. The overall-width, font-ascent and +/// font-descent are as returned by `xcb_query_text_extents` (TODO). +/// +/// Note that using X core fonts is deprecated (but still supported) in favor of +/// client-side rendering using Xft. +/// +/// # Fields +/// +/// * `drawable` - The drawable (Window or Pixmap) to draw text on. +/// * `string_len` - The length of the `string`. Note that this parameter limited by 255 due to +/// using 8 bits! +/// * `string` - The string to draw. Only the first 255 characters are relevant due to the data +/// type of `string_len`. +/// * `x` - The x coordinate of the first character, relative to the origin of `drawable`. +/// * `y` - The y coordinate of the first character, relative to the origin of `drawable`. +/// * `gc` - The graphics context to use. +/// +/// The following graphics context components are used: plane-mask, foreground, +/// background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask. +/// +/// # Errors +/// +/// * `Drawable` - The specified `drawable` (Window or Pixmap) does not exist. +/// * `GContext` - The specified graphics context does not exist. +/// * `Match` - TODO: reasons? +/// +/// # See +/// +/// * `ImageText16`: request +pub fn image_text8<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let string_len = u8::try_from(string.len()).expect("`string` has too many elements"); - let string_len_bytes = string_len.serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let mut request0 = [ - IMAGE_TEXT8_REQUEST, - string_len_bytes[0], - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + string.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(string), IoSlice::new(&padding0)], vec![])?) + let request0 = ImageText8Request { + drawable, + gc, + x, + y, + string, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ImageText16 request @@ -14520,44 +17683,106 @@ pub const IMAGE_TEXT16_REQUEST: u8 = 77; /// # See /// /// * `ImageText8`: request -pub fn image_text16<'c, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &[Char2b]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ImageText16Request<'input> { + pub drawable: Drawable, + pub gc: Gcontext, + pub x: i16, + pub y: i16, + pub string: &'input [Char2b], +} +impl<'input> ImageText16Request<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let string_len = u8::try_from(self.string.len()).expect("`string` has too many elements"); + let string_len_bytes = string_len.serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let mut request0 = vec![ + IMAGE_TEXT16_REQUEST, + string_len_bytes[0], + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let string_bytes = self.string.serialize(); + let length_so_far = length_so_far + string_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), string_bytes.into(), padding0.into()], vec![])) + } +} +/// Draws text. +/// +/// Fills the destination rectangle with the background pixel from `gc`, then +/// paints the text with the foreground pixel from `gc`. The upper-left corner of +/// the filled rectangle is at [x, y - font-ascent]. The width is overall-width, +/// the height is font-ascent + font-descent. The overall-width, font-ascent and +/// font-descent are as returned by `xcb_query_text_extents` (TODO). +/// +/// Note that using X core fonts is deprecated (but still supported) in favor of +/// client-side rendering using Xft. +/// +/// # Fields +/// +/// * `drawable` - The drawable (Window or Pixmap) to draw text on. +/// * `string_len` - The length of the `string` in characters. Note that this parameter limited by +/// 255 due to using 8 bits! +/// * `string` - The string to draw. Only the first 255 characters are relevant due to the data +/// type of `string_len`. Every character uses 2 bytes (hence the 16 in this +/// request's name). +/// * `x` - The x coordinate of the first character, relative to the origin of `drawable`. +/// * `y` - The y coordinate of the first character, relative to the origin of `drawable`. +/// * `gc` - The graphics context to use. +/// +/// The following graphics context components are used: plane-mask, foreground, +/// background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask. +/// +/// # Errors +/// +/// * `Drawable` - The specified `drawable` (Window or Pixmap) does not exist. +/// * `GContext` - The specified graphics context does not exist. +/// * `Match` - TODO: reasons? +/// +/// # See +/// +/// * `ImageText8`: request +pub fn image_text16<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &'input [Char2b]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let string_len = u8::try_from(string.len()).expect("`string` has too many elements"); - let string_len_bytes = string_len.serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let mut request0 = [ - IMAGE_TEXT16_REQUEST, - string_len_bytes[0], - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let string_bytes = string.serialize(); - let length_so_far = length_so_far + string_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&string_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ImageText16Request { + drawable, + gc, + x, + y, + string, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -14632,168 +17857,290 @@ impl TryFrom for ColormapAlloc { /// Opcode for the CreateColormap request pub const CREATE_COLORMAP_REQUEST: u8 = 78; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateColormapRequest { + pub alloc: ColormapAlloc, + pub mid: Colormap, + pub window: Window, + pub visual: Visualid, +} +impl CreateColormapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let alloc_bytes = u8::from(self.alloc).serialize(); + let mid_bytes = self.mid.serialize(); + let window_bytes = self.window.serialize(); + let visual_bytes = self.visual.serialize(); + let mut request0 = vec![ + CREATE_COLORMAP_REQUEST, + alloc_bytes[0], + 0, + 0, + mid_bytes[0], + mid_bytes[1], + mid_bytes[2], + mid_bytes[3], + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + visual_bytes[0], + visual_bytes[1], + visual_bytes[2], + visual_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_colormap(conn: &Conn, alloc: ColormapAlloc, mid: Colormap, window: Window, visual: Visualid) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let alloc_bytes = u8::from(alloc).serialize(); - let mid_bytes = mid.serialize(); - let window_bytes = window.serialize(); - let visual_bytes = visual.serialize(); - let mut request0 = [ - CREATE_COLORMAP_REQUEST, - alloc_bytes[0], - 0, - 0, - mid_bytes[0], - mid_bytes[1], - mid_bytes[2], - mid_bytes[3], - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - visual_bytes[0], - visual_bytes[1], - visual_bytes[2], - visual_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateColormapRequest { + alloc, + mid, + window, + visual, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the FreeColormap request pub const FREE_COLORMAP_REQUEST: u8 = 79; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FreeColormapRequest { + pub cmap: Colormap, +} +impl FreeColormapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cmap_bytes = self.cmap.serialize(); + let mut request0 = vec![ + FREE_COLORMAP_REQUEST, + 0, + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn free_colormap(conn: &Conn, cmap: Colormap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cmap_bytes = cmap.serialize(); - let mut request0 = [ - FREE_COLORMAP_REQUEST, - 0, - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FreeColormapRequest { + cmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CopyColormapAndFree request pub const COPY_COLORMAP_AND_FREE_REQUEST: u8 = 80; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CopyColormapAndFreeRequest { + pub mid: Colormap, + pub src_cmap: Colormap, +} +impl CopyColormapAndFreeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mid_bytes = self.mid.serialize(); + let src_cmap_bytes = self.src_cmap.serialize(); + let mut request0 = vec![ + COPY_COLORMAP_AND_FREE_REQUEST, + 0, + 0, + 0, + mid_bytes[0], + mid_bytes[1], + mid_bytes[2], + mid_bytes[3], + src_cmap_bytes[0], + src_cmap_bytes[1], + src_cmap_bytes[2], + src_cmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn copy_colormap_and_free(conn: &Conn, mid: Colormap, src_cmap: Colormap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mid_bytes = mid.serialize(); - let src_cmap_bytes = src_cmap.serialize(); - let mut request0 = [ - COPY_COLORMAP_AND_FREE_REQUEST, - 0, - 0, - 0, - mid_bytes[0], - mid_bytes[1], - mid_bytes[2], - mid_bytes[3], - src_cmap_bytes[0], - src_cmap_bytes[1], - src_cmap_bytes[2], - src_cmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CopyColormapAndFreeRequest { + mid, + src_cmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the InstallColormap request pub const INSTALL_COLORMAP_REQUEST: u8 = 81; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct InstallColormapRequest { + pub cmap: Colormap, +} +impl InstallColormapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cmap_bytes = self.cmap.serialize(); + let mut request0 = vec![ + INSTALL_COLORMAP_REQUEST, + 0, + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn install_colormap(conn: &Conn, cmap: Colormap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cmap_bytes = cmap.serialize(); - let mut request0 = [ - INSTALL_COLORMAP_REQUEST, - 0, - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = InstallColormapRequest { + cmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the UninstallColormap request pub const UNINSTALL_COLORMAP_REQUEST: u8 = 82; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UninstallColormapRequest { + pub cmap: Colormap, +} +impl UninstallColormapRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cmap_bytes = self.cmap.serialize(); + let mut request0 = vec![ + UNINSTALL_COLORMAP_REQUEST, + 0, + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn uninstall_colormap(conn: &Conn, cmap: Colormap) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cmap_bytes = cmap.serialize(); - let mut request0 = [ - UNINSTALL_COLORMAP_REQUEST, - 0, - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UninstallColormapRequest { + cmap, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ListInstalledColormaps request pub const LIST_INSTALLED_COLORMAPS_REQUEST: u8 = 83; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListInstalledColormapsRequest { + pub window: Window, +} +impl ListInstalledColormapsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + LIST_INSTALLED_COLORMAPS_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_installed_colormaps(conn: &Conn, window: Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - LIST_INSTALLED_COLORMAPS_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListInstalledColormapsRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -14858,38 +18205,81 @@ pub const ALLOC_COLOR_REQUEST: u8 = 84; /// # Errors /// /// * `Colormap` - The specified colormap `cmap` does not exist. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AllocColorRequest { + pub cmap: Colormap, + pub red: u16, + pub green: u16, + pub blue: u16, +} +impl AllocColorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cmap_bytes = self.cmap.serialize(); + let red_bytes = self.red.serialize(); + let green_bytes = self.green.serialize(); + let blue_bytes = self.blue.serialize(); + let mut request0 = vec![ + ALLOC_COLOR_REQUEST, + 0, + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + red_bytes[0], + red_bytes[1], + green_bytes[0], + green_bytes[1], + blue_bytes[0], + blue_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Allocate a color. +/// +/// Allocates a read-only colormap entry corresponding to the closest RGB value +/// supported by the hardware. If you are using TrueColor, you can take a shortcut +/// and directly calculate the color pixel value to avoid the round trip. But, for +/// example, on 16-bit color setups (VNC), you can easily get the closest supported +/// RGB value to the RGB value you are specifying. +/// +/// # Fields +/// +/// * `cmap` - TODO +/// * `red` - The red value of your color. +/// * `green` - The green value of your color. +/// * `blue` - The blue value of your color. +/// +/// # Errors +/// +/// * `Colormap` - The specified colormap `cmap` does not exist. pub fn alloc_color(conn: &Conn, cmap: Colormap, red: u16, green: u16, blue: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cmap_bytes = cmap.serialize(); - let red_bytes = red.serialize(); - let green_bytes = green.serialize(); - let blue_bytes = blue.serialize(); - let mut request0 = [ - ALLOC_COLOR_REQUEST, - 0, - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - red_bytes[0], - red_bytes[1], - green_bytes[0], - green_bytes[1], - blue_bytes[0], - blue_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = AllocColorRequest { + cmap, + red, + green, + blue, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -14926,36 +18316,57 @@ impl TryFrom<&[u8]> for AllocColorReply { /// Opcode for the AllocNamedColor request pub const ALLOC_NAMED_COLOR_REQUEST: u8 = 85; -pub fn alloc_named_color<'c, Conn>(conn: &'c Conn, cmap: Colormap, name: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AllocNamedColorRequest<'input> { + pub cmap: Colormap, + pub name: &'input [u8], +} +impl<'input> AllocNamedColorRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cmap_bytes = self.cmap.serialize(); + let name_len = u16::try_from(self.name.len()).expect("`name` has too many elements"); + let name_len_bytes = name_len.serialize(); + let mut request0 = vec![ + ALLOC_NAMED_COLOR_REQUEST, + 0, + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + name_len_bytes[0], + name_len_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) + } +} +pub fn alloc_named_color<'c, 'input, Conn>(conn: &'c Conn, cmap: Colormap, name: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cmap_bytes = cmap.serialize(); - let name_len = u16::try_from(name.len()).expect("`name` has too many elements"); - let name_len_bytes = name_len.serialize(); - let mut request0 = [ - ALLOC_NAMED_COLOR_REQUEST, - 0, - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - name_len_bytes[0], - name_len_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) + let request0 = AllocNamedColorRequest { + cmap, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -14997,34 +18408,59 @@ impl TryFrom<&[u8]> for AllocNamedColorReply { /// Opcode for the AllocColorCells request pub const ALLOC_COLOR_CELLS_REQUEST: u8 = 86; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AllocColorCellsRequest { + pub contiguous: bool, + pub cmap: Colormap, + pub colors: u16, + pub planes: u16, +} +impl AllocColorCellsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let contiguous_bytes = self.contiguous.serialize(); + let cmap_bytes = self.cmap.serialize(); + let colors_bytes = self.colors.serialize(); + let planes_bytes = self.planes.serialize(); + let mut request0 = vec![ + ALLOC_COLOR_CELLS_REQUEST, + contiguous_bytes[0], + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + colors_bytes[0], + colors_bytes[1], + planes_bytes[0], + planes_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn alloc_color_cells(conn: &Conn, contiguous: bool, cmap: Colormap, colors: u16, planes: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let contiguous_bytes = contiguous.serialize(); - let cmap_bytes = cmap.serialize(); - let colors_bytes = colors.serialize(); - let planes_bytes = planes.serialize(); - let mut request0 = [ - ALLOC_COLOR_CELLS_REQUEST, - contiguous_bytes[0], - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - colors_bytes[0], - colors_bytes[1], - planes_bytes[0], - planes_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = AllocColorCellsRequest { + contiguous, + cmap, + colors, + planes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -15087,40 +18523,69 @@ impl AllocColorCellsReply { /// Opcode for the AllocColorPlanes request pub const ALLOC_COLOR_PLANES_REQUEST: u8 = 87; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AllocColorPlanesRequest { + pub contiguous: bool, + pub cmap: Colormap, + pub colors: u16, + pub reds: u16, + pub greens: u16, + pub blues: u16, +} +impl AllocColorPlanesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let contiguous_bytes = self.contiguous.serialize(); + let cmap_bytes = self.cmap.serialize(); + let colors_bytes = self.colors.serialize(); + let reds_bytes = self.reds.serialize(); + let greens_bytes = self.greens.serialize(); + let blues_bytes = self.blues.serialize(); + let mut request0 = vec![ + ALLOC_COLOR_PLANES_REQUEST, + contiguous_bytes[0], + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + colors_bytes[0], + colors_bytes[1], + reds_bytes[0], + reds_bytes[1], + greens_bytes[0], + greens_bytes[1], + blues_bytes[0], + blues_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn alloc_color_planes(conn: &Conn, contiguous: bool, cmap: Colormap, colors: u16, reds: u16, greens: u16, blues: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let contiguous_bytes = contiguous.serialize(); - let cmap_bytes = cmap.serialize(); - let colors_bytes = colors.serialize(); - let reds_bytes = reds.serialize(); - let greens_bytes = greens.serialize(); - let blues_bytes = blues.serialize(); - let mut request0 = [ - ALLOC_COLOR_PLANES_REQUEST, - contiguous_bytes[0], - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - colors_bytes[0], - colors_bytes[1], - reds_bytes[0], - reds_bytes[1], - greens_bytes[0], - greens_bytes[1], - blues_bytes[0], - blues_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = AllocColorPlanesRequest { + contiguous, + cmap, + colors, + reds, + greens, + blues, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -15174,36 +18639,59 @@ impl AllocColorPlanesReply { /// Opcode for the FreeColors request pub const FREE_COLORS_REQUEST: u8 = 88; -pub fn free_colors<'c, Conn>(conn: &'c Conn, cmap: Colormap, plane_mask: u32, pixels: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FreeColorsRequest<'input> { + pub cmap: Colormap, + pub plane_mask: u32, + pub pixels: &'input [u32], +} +impl<'input> FreeColorsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cmap_bytes = self.cmap.serialize(); + let plane_mask_bytes = self.plane_mask.serialize(); + let mut request0 = vec![ + FREE_COLORS_REQUEST, + 0, + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + plane_mask_bytes[0], + plane_mask_bytes[1], + plane_mask_bytes[2], + plane_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let pixels_bytes = self.pixels.serialize(); + let length_so_far = length_so_far + pixels_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), pixels_bytes.into(), padding0.into()], vec![])) + } +} +pub fn free_colors<'c, 'input, Conn>(conn: &'c Conn, cmap: Colormap, plane_mask: u32, pixels: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cmap_bytes = cmap.serialize(); - let plane_mask_bytes = plane_mask.serialize(); - let mut request0 = [ - FREE_COLORS_REQUEST, - 0, - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - plane_mask_bytes[0], - plane_mask_bytes[1], - plane_mask_bytes[2], - plane_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let pixels_bytes = pixels.serialize(); - let length_so_far = length_so_far + pixels_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&pixels_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = FreeColorsRequest { + cmap, + plane_mask, + pixels, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -15334,73 +18822,119 @@ impl Serialize for Coloritem { /// Opcode for the StoreColors request pub const STORE_COLORS_REQUEST: u8 = 89; -pub fn store_colors<'c, Conn>(conn: &'c Conn, cmap: Colormap, items: &[Coloritem]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct StoreColorsRequest<'input> { + pub cmap: Colormap, + pub items: &'input [Coloritem], +} +impl<'input> StoreColorsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cmap_bytes = self.cmap.serialize(); + let mut request0 = vec![ + STORE_COLORS_REQUEST, + 0, + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let items_bytes = self.items.serialize(); + let length_so_far = length_so_far + items_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), items_bytes.into(), padding0.into()], vec![])) + } +} +pub fn store_colors<'c, 'input, Conn>(conn: &'c Conn, cmap: Colormap, items: &'input [Coloritem]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cmap_bytes = cmap.serialize(); - let mut request0 = [ - STORE_COLORS_REQUEST, - 0, - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let items_bytes = items.serialize(); - let length_so_far = length_so_far + items_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&items_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = StoreColorsRequest { + cmap, + items, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the StoreNamedColor request pub const STORE_NAMED_COLOR_REQUEST: u8 = 90; -pub fn store_named_color<'c, Conn, A>(conn: &'c Conn, flags: A, cmap: Colormap, pixel: u32, name: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct StoreNamedColorRequest<'input> { + pub flags: u8, + pub cmap: Colormap, + pub pixel: u32, + pub name: &'input [u8], +} +impl<'input> StoreNamedColorRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let flags_bytes = self.flags.serialize(); + let cmap_bytes = self.cmap.serialize(); + let pixel_bytes = self.pixel.serialize(); + let name_len = u16::try_from(self.name.len()).expect("`name` has too many elements"); + let name_len_bytes = name_len.serialize(); + let mut request0 = vec![ + STORE_NAMED_COLOR_REQUEST, + flags_bytes[0], + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + pixel_bytes[0], + pixel_bytes[1], + pixel_bytes[2], + pixel_bytes[3], + name_len_bytes[0], + name_len_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) + } +} +pub fn store_named_color<'c, 'input, Conn, A>(conn: &'c Conn, flags: A, cmap: Colormap, pixel: u32, name: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { let flags: u8 = flags.into(); - let length_so_far = 0; - let flags_bytes = flags.serialize(); - let cmap_bytes = cmap.serialize(); - let pixel_bytes = pixel.serialize(); - let name_len = u16::try_from(name.len()).expect("`name` has too many elements"); - let name_len_bytes = name_len.serialize(); - let mut request0 = [ - STORE_NAMED_COLOR_REQUEST, - flags_bytes[0], - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - pixel_bytes[0], - pixel_bytes[1], - pixel_bytes[2], - pixel_bytes[3], - name_len_bytes[0], - name_len_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) + let request0 = StoreNamedColorRequest { + flags, + cmap, + pixel, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -15453,31 +18987,52 @@ impl Serialize for Rgb { /// Opcode for the QueryColors request pub const QUERY_COLORS_REQUEST: u8 = 91; -pub fn query_colors<'c, Conn>(conn: &'c Conn, cmap: Colormap, pixels: &[u32]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct QueryColorsRequest<'input> { + pub cmap: Colormap, + pub pixels: &'input [u32], +} +impl<'input> QueryColorsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cmap_bytes = self.cmap.serialize(); + let mut request0 = vec![ + QUERY_COLORS_REQUEST, + 0, + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let pixels_bytes = self.pixels.serialize(); + let length_so_far = length_so_far + pixels_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), pixels_bytes.into(), padding0.into()], vec![])) + } +} +pub fn query_colors<'c, 'input, Conn>(conn: &'c Conn, cmap: Colormap, pixels: &'input [u32]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cmap_bytes = cmap.serialize(); - let mut request0 = [ - QUERY_COLORS_REQUEST, - 0, - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let pixels_bytes = pixels.serialize(); - let length_so_far = length_so_far + pixels_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(&pixels_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = QueryColorsRequest { + cmap, + pixels, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -15524,36 +19079,57 @@ impl QueryColorsReply { /// Opcode for the LookupColor request pub const LOOKUP_COLOR_REQUEST: u8 = 92; -pub fn lookup_color<'c, Conn>(conn: &'c Conn, cmap: Colormap, name: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct LookupColorRequest<'input> { + pub cmap: Colormap, + pub name: &'input [u8], +} +impl<'input> LookupColorRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cmap_bytes = self.cmap.serialize(); + let name_len = u16::try_from(self.name.len()).expect("`name` has too many elements"); + let name_len_bytes = name_len.serialize(); + let mut request0 = vec![ + LOOKUP_COLOR_REQUEST, + 0, + 0, + 0, + cmap_bytes[0], + cmap_bytes[1], + cmap_bytes[2], + cmap_bytes[3], + name_len_bytes[0], + name_len_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) + } +} +pub fn lookup_color<'c, 'input, Conn>(conn: &'c Conn, cmap: Colormap, name: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cmap_bytes = cmap.serialize(); - let name_len = u16::try_from(name.len()).expect("`name` has too many elements"); - let name_len_bytes = name_len.serialize(); - let mut request0 = [ - LOOKUP_COLOR_REQUEST, - 0, - 0, - 0, - cmap_bytes[0], - cmap_bytes[1], - cmap_bytes[2], - cmap_bytes[3], - name_len_bytes[0], - name_len_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) + let request0 = LookupColorRequest { + cmap, + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -15652,63 +19228,102 @@ impl TryFrom for PixmapEnum { /// Opcode for the CreateCursor request pub const CREATE_CURSOR_REQUEST: u8 = 93; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateCursorRequest { + pub cid: Cursor, + pub source: Pixmap, + pub mask: Pixmap, + pub fore_red: u16, + pub fore_green: u16, + pub fore_blue: u16, + pub back_red: u16, + pub back_green: u16, + pub back_blue: u16, + pub x: u16, + pub y: u16, +} +impl CreateCursorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cid_bytes = self.cid.serialize(); + let source_bytes = self.source.serialize(); + let mask_bytes = self.mask.serialize(); + let fore_red_bytes = self.fore_red.serialize(); + let fore_green_bytes = self.fore_green.serialize(); + let fore_blue_bytes = self.fore_blue.serialize(); + let back_red_bytes = self.back_red.serialize(); + let back_green_bytes = self.back_green.serialize(); + let back_blue_bytes = self.back_blue.serialize(); + let x_bytes = self.x.serialize(); + let y_bytes = self.y.serialize(); + let mut request0 = vec![ + CREATE_CURSOR_REQUEST, + 0, + 0, + 0, + cid_bytes[0], + cid_bytes[1], + cid_bytes[2], + cid_bytes[3], + source_bytes[0], + source_bytes[1], + source_bytes[2], + source_bytes[3], + mask_bytes[0], + mask_bytes[1], + mask_bytes[2], + mask_bytes[3], + fore_red_bytes[0], + fore_red_bytes[1], + fore_green_bytes[0], + fore_green_bytes[1], + fore_blue_bytes[0], + fore_blue_bytes[1], + back_red_bytes[0], + back_red_bytes[1], + back_green_bytes[0], + back_green_bytes[1], + back_blue_bytes[0], + back_blue_bytes[1], + x_bytes[0], + x_bytes[1], + y_bytes[0], + y_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_cursor(conn: &Conn, cid: Cursor, source: Pixmap, mask: A, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { let mask: Pixmap = mask.into(); - let length_so_far = 0; - let cid_bytes = cid.serialize(); - let source_bytes = source.serialize(); - let mask_bytes = mask.serialize(); - let fore_red_bytes = fore_red.serialize(); - let fore_green_bytes = fore_green.serialize(); - let fore_blue_bytes = fore_blue.serialize(); - let back_red_bytes = back_red.serialize(); - let back_green_bytes = back_green.serialize(); - let back_blue_bytes = back_blue.serialize(); - let x_bytes = x.serialize(); - let y_bytes = y.serialize(); - let mut request0 = [ - CREATE_CURSOR_REQUEST, - 0, - 0, - 0, - cid_bytes[0], - cid_bytes[1], - cid_bytes[2], - cid_bytes[3], - source_bytes[0], - source_bytes[1], - source_bytes[2], - source_bytes[3], - mask_bytes[0], - mask_bytes[1], - mask_bytes[2], - mask_bytes[3], - fore_red_bytes[0], - fore_red_bytes[1], - fore_green_bytes[0], - fore_green_bytes[1], - fore_blue_bytes[0], - fore_blue_bytes[1], - back_red_bytes[0], - back_red_bytes[1], - back_green_bytes[0], - back_green_bytes[1], - back_blue_bytes[0], - back_blue_bytes[1], - x_bytes[0], - x_bytes[1], - y_bytes[0], - y_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateCursorRequest { + cid, + source, + mask, + fore_red, + fore_green, + fore_blue, + back_red, + back_green, + back_blue, + x, + y, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -15805,63 +19420,135 @@ pub const CREATE_GLYPH_CURSOR_REQUEST: u8 = 94; /// * `Alloc` - The X server could not allocate the requested resources (no memory?). /// * `Font` - The specified `source_font` or `mask_font` does not exist. /// * `Value` - Either `source_char` or `mask_char` are not defined in `source_font` or `mask_font`, respectively. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateGlyphCursorRequest { + pub cid: Cursor, + pub source_font: Font, + pub mask_font: Font, + pub source_char: u16, + pub mask_char: u16, + pub fore_red: u16, + pub fore_green: u16, + pub fore_blue: u16, + pub back_red: u16, + pub back_green: u16, + pub back_blue: u16, +} +impl CreateGlyphCursorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cid_bytes = self.cid.serialize(); + let source_font_bytes = self.source_font.serialize(); + let mask_font_bytes = self.mask_font.serialize(); + let source_char_bytes = self.source_char.serialize(); + let mask_char_bytes = self.mask_char.serialize(); + let fore_red_bytes = self.fore_red.serialize(); + let fore_green_bytes = self.fore_green.serialize(); + let fore_blue_bytes = self.fore_blue.serialize(); + let back_red_bytes = self.back_red.serialize(); + let back_green_bytes = self.back_green.serialize(); + let back_blue_bytes = self.back_blue.serialize(); + let mut request0 = vec![ + CREATE_GLYPH_CURSOR_REQUEST, + 0, + 0, + 0, + cid_bytes[0], + cid_bytes[1], + cid_bytes[2], + cid_bytes[3], + source_font_bytes[0], + source_font_bytes[1], + source_font_bytes[2], + source_font_bytes[3], + mask_font_bytes[0], + mask_font_bytes[1], + mask_font_bytes[2], + mask_font_bytes[3], + source_char_bytes[0], + source_char_bytes[1], + mask_char_bytes[0], + mask_char_bytes[1], + fore_red_bytes[0], + fore_red_bytes[1], + fore_green_bytes[0], + fore_green_bytes[1], + fore_blue_bytes[0], + fore_blue_bytes[1], + back_red_bytes[0], + back_red_bytes[1], + back_green_bytes[0], + back_green_bytes[1], + back_blue_bytes[0], + back_blue_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// create cursor. +/// +/// Creates a cursor from a font glyph. X provides a set of standard cursor shapes +/// in a special font named cursor. Applications are encouraged to use this +/// interface for their cursors because the font can be customized for the +/// individual display type. +/// +/// All pixels which are set to 1 in the source will use the foreground color (as +/// specified by `fore_red`, `fore_green` and `fore_blue`). All pixels set to 0 +/// will use the background color (as specified by `back_red`, `back_green` and +/// `back_blue`). +/// +/// # Fields +/// +/// * `cid` - The ID with which you will refer to the cursor, created by `xcb_generate_id`. +/// * `source_font` - In which font to look for the cursor glyph. +/// * `mask_font` - In which font to look for the mask glyph. +/// * `source_char` - The glyph of `source_font` to use. +/// * `mask_char` - The glyph of `mask_font` to use as a mask: Pixels which are set to 1 define +/// which source pixels are displayed. All pixels which are set to 0 are not +/// displayed. +/// * `fore_red` - The red value of the foreground color. +/// * `fore_green` - The green value of the foreground color. +/// * `fore_blue` - The blue value of the foreground color. +/// * `back_red` - The red value of the background color. +/// * `back_green` - The green value of the background color. +/// * `back_blue` - The blue value of the background color. +/// +/// # Errors +/// +/// * `Alloc` - The X server could not allocate the requested resources (no memory?). +/// * `Font` - The specified `source_font` or `mask_font` does not exist. +/// * `Value` - Either `source_char` or `mask_char` are not defined in `source_font` or `mask_font`, respectively. pub fn create_glyph_cursor(conn: &Conn, cid: Cursor, source_font: Font, mask_font: A, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { let mask_font: Font = mask_font.into(); - let length_so_far = 0; - let cid_bytes = cid.serialize(); - let source_font_bytes = source_font.serialize(); - let mask_font_bytes = mask_font.serialize(); - let source_char_bytes = source_char.serialize(); - let mask_char_bytes = mask_char.serialize(); - let fore_red_bytes = fore_red.serialize(); - let fore_green_bytes = fore_green.serialize(); - let fore_blue_bytes = fore_blue.serialize(); - let back_red_bytes = back_red.serialize(); - let back_green_bytes = back_green.serialize(); - let back_blue_bytes = back_blue.serialize(); - let mut request0 = [ - CREATE_GLYPH_CURSOR_REQUEST, - 0, - 0, - 0, - cid_bytes[0], - cid_bytes[1], - cid_bytes[2], - cid_bytes[3], - source_font_bytes[0], - source_font_bytes[1], - source_font_bytes[2], - source_font_bytes[3], - mask_font_bytes[0], - mask_font_bytes[1], - mask_font_bytes[2], - mask_font_bytes[3], - source_char_bytes[0], - source_char_bytes[1], - mask_char_bytes[0], - mask_char_bytes[1], - fore_red_bytes[0], - fore_red_bytes[1], - fore_green_bytes[0], - fore_green_bytes[1], - fore_blue_bytes[0], - fore_blue_bytes[1], - back_red_bytes[0], - back_red_bytes[1], - back_green_bytes[0], - back_green_bytes[1], - back_blue_bytes[0], - back_blue_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateGlyphCursorRequest { + cid, + source_font, + mask_font, + source_char, + mask_char, + fore_red, + fore_green, + fore_blue, + back_red, + back_green, + back_blue, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the FreeCursor request @@ -15878,70 +19565,132 @@ pub const FREE_CURSOR_REQUEST: u8 = 95; /// # Errors /// /// * `Cursor` - The specified cursor does not exist. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FreeCursorRequest { + pub cursor: Cursor, +} +impl FreeCursorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cursor_bytes = self.cursor.serialize(); + let mut request0 = vec![ + FREE_CURSOR_REQUEST, + 0, + 0, + 0, + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// Deletes a cursor. +/// +/// Deletes the association between the cursor resource ID and the specified +/// cursor. The cursor is freed when no other resource references it. +/// +/// # Fields +/// +/// * `cursor` - The cursor to destroy. +/// +/// # Errors +/// +/// * `Cursor` - The specified cursor does not exist. pub fn free_cursor(conn: &Conn, cursor: Cursor) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cursor_bytes = cursor.serialize(); - let mut request0 = [ - FREE_CURSOR_REQUEST, - 0, - 0, - 0, - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FreeCursorRequest { + cursor, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the RecolorCursor request pub const RECOLOR_CURSOR_REQUEST: u8 = 96; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct RecolorCursorRequest { + pub cursor: Cursor, + pub fore_red: u16, + pub fore_green: u16, + pub fore_blue: u16, + pub back_red: u16, + pub back_green: u16, + pub back_blue: u16, +} +impl RecolorCursorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let cursor_bytes = self.cursor.serialize(); + let fore_red_bytes = self.fore_red.serialize(); + let fore_green_bytes = self.fore_green.serialize(); + let fore_blue_bytes = self.fore_blue.serialize(); + let back_red_bytes = self.back_red.serialize(); + let back_green_bytes = self.back_green.serialize(); + let back_blue_bytes = self.back_blue.serialize(); + let mut request0 = vec![ + RECOLOR_CURSOR_REQUEST, + 0, + 0, + 0, + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + fore_red_bytes[0], + fore_red_bytes[1], + fore_green_bytes[0], + fore_green_bytes[1], + fore_blue_bytes[0], + fore_blue_bytes[1], + back_red_bytes[0], + back_red_bytes[1], + back_green_bytes[0], + back_green_bytes[1], + back_blue_bytes[0], + back_blue_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn recolor_cursor(conn: &Conn, cursor: Cursor, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let cursor_bytes = cursor.serialize(); - let fore_red_bytes = fore_red.serialize(); - let fore_green_bytes = fore_green.serialize(); - let fore_blue_bytes = fore_blue.serialize(); - let back_red_bytes = back_red.serialize(); - let back_green_bytes = back_green.serialize(); - let back_blue_bytes = back_blue.serialize(); - let mut request0 = [ - RECOLOR_CURSOR_REQUEST, - 0, - 0, - 0, - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - fore_red_bytes[0], - fore_red_bytes[1], - fore_green_bytes[0], - fore_green_bytes[1], - fore_blue_bytes[0], - fore_blue_bytes[1], - back_red_bytes[0], - back_red_bytes[1], - back_green_bytes[0], - back_green_bytes[1], - back_blue_bytes[0], - back_blue_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = RecolorCursorRequest { + cursor, + fore_red, + fore_green, + fore_blue, + back_red, + back_green, + back_blue, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -16011,34 +19760,59 @@ impl TryFrom for QueryShapeOf { /// Opcode for the QueryBestSize request pub const QUERY_BEST_SIZE_REQUEST: u8 = 97; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryBestSizeRequest { + pub class: QueryShapeOf, + pub drawable: Drawable, + pub width: u16, + pub height: u16, +} +impl QueryBestSizeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let class_bytes = u8::from(self.class).serialize(); + let drawable_bytes = self.drawable.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let mut request0 = vec![ + QUERY_BEST_SIZE_REQUEST, + class_bytes[0], + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_best_size(conn: &Conn, class: QueryShapeOf, drawable: Drawable, width: u16, height: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let class_bytes = u8::from(class).serialize(); - let drawable_bytes = drawable.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let mut request0 = [ - QUERY_BEST_SIZE_REQUEST, - class_bytes[0], - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryBestSizeRequest { + class, + drawable, + width, + height, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -16067,9 +19841,65 @@ impl TryFrom<&[u8]> for QueryBestSizeReply { Ok(Self::try_parse(value)?.0) } } - -/// Opcode for the QueryExtension request -pub const QUERY_EXTENSION_REQUEST: u8 = 98; + +/// Opcode for the QueryExtension request +pub const QUERY_EXTENSION_REQUEST: u8 = 98; +/// check if extension is present. +/// +/// Determines if the specified extension is present on this X11 server. +/// +/// Every extension has a unique `major_opcode` to identify requests, the minor +/// opcodes and request formats are extension-specific. If the extension provides +/// events and errors, the `first_event` and `first_error` fields in the reply are +/// set accordingly. +/// +/// There should rarely be a need to use this request directly, XCB provides the +/// `xcb_get_extension_data` function instead. +/// +/// # Fields +/// +/// * `name_len` - The length of `name` in bytes. +/// * `name` - The name of the extension to query, for example "RANDR". This is case +/// sensitive! +/// +/// # See +/// +/// * `xdpyinfo`: program +/// * `xcb_get_extension_data`: function +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct QueryExtensionRequest<'input> { + pub name: &'input [u8], +} +impl<'input> QueryExtensionRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let name_len = u16::try_from(self.name.len()).expect("`name` has too many elements"); + let name_len_bytes = name_len.serialize(); + let mut request0 = vec![ + QUERY_EXTENSION_REQUEST, + 0, + 0, + 0, + name_len_bytes[0], + name_len_bytes[1], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.name[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.name[..]).into(), padding0.into()], vec![])) + } +} /// check if extension is present. /// /// Determines if the specified extension is present on this X11 server. @@ -16092,31 +19922,16 @@ pub const QUERY_EXTENSION_REQUEST: u8 = 98; /// /// * `xdpyinfo`: program /// * `xcb_get_extension_data`: function -pub fn query_extension<'c, Conn>(conn: &'c Conn, name: &[u8]) -> Result, ConnectionError> +pub fn query_extension<'c, 'input, Conn>(conn: &'c Conn, name: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let name_len = u16::try_from(name.len()).expect("`name` has too many elements"); - let name_len_bytes = name_len.serialize(); - let mut request0 = [ - QUERY_EXTENSION_REQUEST, - 0, - 0, - 0, - name_len_bytes[0], - name_len_bytes[1], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + name.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(name), IoSlice::new(&padding0)], vec![])?) + let request0 = QueryExtensionRequest { + name, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } /// # Fields @@ -16158,22 +19973,37 @@ impl TryFrom<&[u8]> for QueryExtensionReply { /// Opcode for the ListExtensions request pub const LIST_EXTENSIONS_REQUEST: u8 = 99; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListExtensionsRequest; +impl ListExtensionsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + LIST_EXTENSIONS_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_extensions(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - LIST_EXTENSIONS_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListExtensionsRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -16219,60 +20049,106 @@ impl ListExtensionsReply { /// Opcode for the ChangeKeyboardMapping request pub const CHANGE_KEYBOARD_MAPPING_REQUEST: u8 = 100; -pub fn change_keyboard_mapping<'c, Conn>(conn: &'c Conn, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: &[Keysym]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeKeyboardMappingRequest<'input> { + pub keycode_count: u8, + pub first_keycode: Keycode, + pub keysyms_per_keycode: u8, + pub keysyms: &'input [Keysym], +} +impl<'input> ChangeKeyboardMappingRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let keycode_count_bytes = self.keycode_count.serialize(); + let first_keycode_bytes = self.first_keycode.serialize(); + let keysyms_per_keycode_bytes = self.keysyms_per_keycode.serialize(); + let mut request0 = vec![ + CHANGE_KEYBOARD_MAPPING_REQUEST, + keycode_count_bytes[0], + 0, + 0, + first_keycode_bytes[0], + keysyms_per_keycode_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(self.keysyms.len(), usize::try_from(u32::from(self.keycode_count).checked_mul(u32::from(self.keysyms_per_keycode)).unwrap()).unwrap(), "`keysyms` has an incorrect length"); + let keysyms_bytes = self.keysyms.serialize(); + let length_so_far = length_so_far + keysyms_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), keysyms_bytes.into(), padding0.into()], vec![])) + } +} +pub fn change_keyboard_mapping<'c, 'input, Conn>(conn: &'c Conn, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: &'input [Keysym]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let keycode_count_bytes = keycode_count.serialize(); - let first_keycode_bytes = first_keycode.serialize(); - let keysyms_per_keycode_bytes = keysyms_per_keycode.serialize(); - let mut request0 = [ - CHANGE_KEYBOARD_MAPPING_REQUEST, - keycode_count_bytes[0], - 0, - 0, - first_keycode_bytes[0], - keysyms_per_keycode_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(keysyms.len(), usize::try_from(u32::from(keycode_count).checked_mul(u32::from(keysyms_per_keycode)).unwrap()).unwrap(), "`keysyms` has an incorrect length"); - let keysyms_bytes = keysyms.serialize(); - let length_so_far = length_so_far + keysyms_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&keysyms_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeKeyboardMappingRequest { + keycode_count, + first_keycode, + keysyms_per_keycode, + keysyms, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetKeyboardMapping request pub const GET_KEYBOARD_MAPPING_REQUEST: u8 = 101; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetKeyboardMappingRequest { + pub first_keycode: Keycode, + pub count: u8, +} +impl GetKeyboardMappingRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let first_keycode_bytes = self.first_keycode.serialize(); + let count_bytes = self.count.serialize(); + let mut request0 = vec![ + GET_KEYBOARD_MAPPING_REQUEST, + 0, + 0, + 0, + first_keycode_bytes[0], + count_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_keyboard_mapping(conn: &Conn, first_keycode: Keycode, count: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let first_keycode_bytes = first_keycode.serialize(); - let count_bytes = count.serialize(); - let mut request0 = [ - GET_KEYBOARD_MAPPING_REQUEST, - 0, - 0, - 0, - first_keycode_bytes[0], - count_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetKeyboardMappingRequest { + first_keycode, + count, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -16532,8 +20408,6 @@ impl TryFrom for AutoRepeatMode { } } -/// Opcode for the ChangeKeyboardControl request -pub const CHANGE_KEYBOARD_CONTROL_REQUEST: u8 = 102; /// Auxiliary and optional information for the `change_keyboard_control` function #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct ChangeKeyboardControlAux { @@ -16657,52 +20531,88 @@ impl ChangeKeyboardControlAux { } } -pub fn change_keyboard_control<'c, Conn>(conn: &'c Conn, value_list: &ChangeKeyboardControlAux) -> Result, ConnectionError> +/// Opcode for the ChangeKeyboardControl request +pub const CHANGE_KEYBOARD_CONTROL_REQUEST: u8 = 102; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangeKeyboardControlRequest<'input> { + pub value_list: &'input ChangeKeyboardControlAux, +} +impl<'input> ChangeKeyboardControlRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let value_mask = u32::try_from(self.value_list.switch_expr()).unwrap(); + let value_mask_bytes = value_mask.serialize(); + let mut request0 = vec![ + CHANGE_KEYBOARD_CONTROL_REQUEST, + 0, + 0, + 0, + value_mask_bytes[0], + value_mask_bytes[1], + value_mask_bytes[2], + value_mask_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let value_list_bytes = self.value_list.serialize(value_mask); + let length_so_far = length_so_far + value_list_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), value_list_bytes.into(), padding0.into()], vec![])) + } +} +pub fn change_keyboard_control<'c, 'input, Conn>(conn: &'c Conn, value_list: &'input ChangeKeyboardControlAux) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let value_mask = u32::try_from(value_list.switch_expr()).unwrap(); - let value_mask_bytes = value_mask.serialize(); - let mut request0 = [ - CHANGE_KEYBOARD_CONTROL_REQUEST, - 0, - 0, - 0, - value_mask_bytes[0], - value_mask_bytes[1], - value_mask_bytes[2], - value_mask_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let value_list_bytes = value_list.serialize(value_mask); - let length_so_far = length_so_far + value_list_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&value_list_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeKeyboardControlRequest { + value_list, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetKeyboardControl request pub const GET_KEYBOARD_CONTROL_REQUEST: u8 = 103; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetKeyboardControlRequest; +impl GetKeyboardControlRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + GET_KEYBOARD_CONTROL_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_keyboard_control(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - GET_KEYBOARD_CONTROL_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetKeyboardControlRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -16746,76 +20656,137 @@ impl TryFrom<&[u8]> for GetKeyboardControlReply { /// Opcode for the Bell request pub const BELL_REQUEST: u8 = 104; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct BellRequest { + pub percent: i8, +} +impl BellRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let percent_bytes = self.percent.serialize(); + let mut request0 = vec![ + BELL_REQUEST, + percent_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn bell(conn: &Conn, percent: i8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let percent_bytes = percent.serialize(); - let mut request0 = [ - BELL_REQUEST, - percent_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = BellRequest { + percent, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ChangePointerControl request pub const CHANGE_POINTER_CONTROL_REQUEST: u8 = 105; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ChangePointerControlRequest { + pub acceleration_numerator: i16, + pub acceleration_denominator: i16, + pub threshold: i16, + pub do_acceleration: bool, + pub do_threshold: bool, +} +impl ChangePointerControlRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let acceleration_numerator_bytes = self.acceleration_numerator.serialize(); + let acceleration_denominator_bytes = self.acceleration_denominator.serialize(); + let threshold_bytes = self.threshold.serialize(); + let do_acceleration_bytes = self.do_acceleration.serialize(); + let do_threshold_bytes = self.do_threshold.serialize(); + let mut request0 = vec![ + CHANGE_POINTER_CONTROL_REQUEST, + 0, + 0, + 0, + acceleration_numerator_bytes[0], + acceleration_numerator_bytes[1], + acceleration_denominator_bytes[0], + acceleration_denominator_bytes[1], + threshold_bytes[0], + threshold_bytes[1], + do_acceleration_bytes[0], + do_threshold_bytes[0], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn change_pointer_control(conn: &Conn, acceleration_numerator: i16, acceleration_denominator: i16, threshold: i16, do_acceleration: bool, do_threshold: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let acceleration_numerator_bytes = acceleration_numerator.serialize(); - let acceleration_denominator_bytes = acceleration_denominator.serialize(); - let threshold_bytes = threshold.serialize(); - let do_acceleration_bytes = do_acceleration.serialize(); - let do_threshold_bytes = do_threshold.serialize(); - let mut request0 = [ - CHANGE_POINTER_CONTROL_REQUEST, - 0, - 0, - 0, - acceleration_numerator_bytes[0], - acceleration_numerator_bytes[1], - acceleration_denominator_bytes[0], - acceleration_denominator_bytes[1], - threshold_bytes[0], - threshold_bytes[1], - do_acceleration_bytes[0], - do_threshold_bytes[0], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ChangePointerControlRequest { + acceleration_numerator, + acceleration_denominator, + threshold, + do_acceleration, + do_threshold, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetPointerControl request pub const GET_POINTER_CONTROL_REQUEST: u8 = 106; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPointerControlRequest; +impl GetPointerControlRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + GET_POINTER_CONTROL_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_pointer_control(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - GET_POINTER_CONTROL_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPointerControlRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -16980,54 +20951,94 @@ impl TryFrom for Exposures { /// Opcode for the SetScreenSaver request pub const SET_SCREEN_SAVER_REQUEST: u8 = 107; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetScreenSaverRequest { + pub timeout: i16, + pub interval: i16, + pub prefer_blanking: Blanking, + pub allow_exposures: Exposures, +} +impl SetScreenSaverRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let timeout_bytes = self.timeout.serialize(); + let interval_bytes = self.interval.serialize(); + let prefer_blanking_bytes = u8::from(self.prefer_blanking).serialize(); + let allow_exposures_bytes = u8::from(self.allow_exposures).serialize(); + let mut request0 = vec![ + SET_SCREEN_SAVER_REQUEST, + 0, + 0, + 0, + timeout_bytes[0], + timeout_bytes[1], + interval_bytes[0], + interval_bytes[1], + prefer_blanking_bytes[0], + allow_exposures_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_screen_saver(conn: &Conn, timeout: i16, interval: i16, prefer_blanking: Blanking, allow_exposures: Exposures) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let timeout_bytes = timeout.serialize(); - let interval_bytes = interval.serialize(); - let prefer_blanking_bytes = u8::from(prefer_blanking).serialize(); - let allow_exposures_bytes = u8::from(allow_exposures).serialize(); - let mut request0 = [ - SET_SCREEN_SAVER_REQUEST, - 0, - 0, - 0, - timeout_bytes[0], - timeout_bytes[1], - interval_bytes[0], - interval_bytes[1], - prefer_blanking_bytes[0], - allow_exposures_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetScreenSaverRequest { + timeout, + interval, + prefer_blanking, + allow_exposures, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetScreenSaver request pub const GET_SCREEN_SAVER_REQUEST: u8 = 108; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetScreenSaverRequest; +impl GetScreenSaverRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + GET_SCREEN_SAVER_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_screen_saver(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - GET_SCREEN_SAVER_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetScreenSaverRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -17207,33 +21218,56 @@ impl TryFrom for Family { /// Opcode for the ChangeHosts request pub const CHANGE_HOSTS_REQUEST: u8 = 109; -pub fn change_hosts<'c, Conn>(conn: &'c Conn, mode: HostMode, family: Family, address: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChangeHostsRequest<'input> { + pub mode: HostMode, + pub family: Family, + pub address: &'input [u8], +} +impl<'input> ChangeHostsRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mode_bytes = u8::from(self.mode).serialize(); + let family_bytes = u8::from(self.family).serialize(); + let address_len = u16::try_from(self.address.len()).expect("`address` has too many elements"); + let address_len_bytes = address_len.serialize(); + let mut request0 = vec![ + CHANGE_HOSTS_REQUEST, + mode_bytes[0], + 0, + 0, + family_bytes[0], + 0, + address_len_bytes[0], + address_len_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.address[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.address[..]).into(), padding0.into()], vec![])) + } +} +pub fn change_hosts<'c, 'input, Conn>(conn: &'c Conn, mode: HostMode, family: Family, address: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mode_bytes = u8::from(mode).serialize(); - let family_bytes = u8::from(family).serialize(); - let address_len = u16::try_from(address.len()).expect("`address` has too many elements"); - let address_len_bytes = address_len.serialize(); - let mut request0 = [ - CHANGE_HOSTS_REQUEST, - mode_bytes[0], - 0, - 0, - family_bytes[0], - 0, - address_len_bytes[0], - address_len_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + address.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(address), IoSlice::new(&padding0)], vec![])?) + let request0 = ChangeHostsRequest { + mode, + family, + address, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -17299,22 +21333,37 @@ impl Host { /// Opcode for the ListHosts request pub const LIST_HOSTS_REQUEST: u8 = 110; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListHostsRequest; +impl ListHostsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + LIST_HOSTS_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_hosts(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - LIST_HOSTS_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListHostsRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -17433,23 +21482,42 @@ impl TryFrom for AccessControl { /// Opcode for the SetAccessControl request pub const SET_ACCESS_CONTROL_REQUEST: u8 = 111; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetAccessControlRequest { + pub mode: AccessControl, +} +impl SetAccessControlRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mode_bytes = u8::from(self.mode).serialize(); + let mut request0 = vec![ + SET_ACCESS_CONTROL_REQUEST, + mode_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_access_control(conn: &Conn, mode: AccessControl) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mode_bytes = u8::from(mode).serialize(); - let mut request0 = [ - SET_ACCESS_CONTROL_REQUEST, - mode_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetAccessControlRequest { + mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -17519,23 +21587,42 @@ impl TryFrom for CloseDown { /// Opcode for the SetCloseDownMode request pub const SET_CLOSE_DOWN_MODE_REQUEST: u8 = 112; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetCloseDownModeRequest { + pub mode: CloseDown, +} +impl SetCloseDownModeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mode_bytes = u8::from(self.mode).serialize(); + let mut request0 = vec![ + SET_CLOSE_DOWN_MODE_REQUEST, + mode_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_close_down_mode(conn: &Conn, mode: CloseDown) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mode_bytes = u8::from(mode).serialize(); - let mut request0 = [ - SET_CLOSE_DOWN_MODE_REQUEST, - mode_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetCloseDownModeRequest { + mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -17618,65 +21705,126 @@ pub const KILL_CLIENT_REQUEST: u8 = 113; /// # See /// /// * `xkill`: program +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct KillClientRequest { + pub resource: u32, +} +impl KillClientRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let resource_bytes = self.resource.serialize(); + let mut request0 = vec![ + KILL_CLIENT_REQUEST, + 0, + 0, + 0, + resource_bytes[0], + resource_bytes[1], + resource_bytes[2], + resource_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} +/// kills a client. +/// +/// Forces a close down of the client that created the specified `resource`. +/// +/// # Fields +/// +/// * `resource` - Any resource belonging to the client (for example a Window), used to identify +/// the client connection. +/// +/// The special value of `XCB_KILL_ALL_TEMPORARY`, the resources of all clients +/// that have terminated in `RetainTemporary` (TODO) are destroyed. +/// +/// # Errors +/// +/// * `Value` - The specified `resource` does not exist. +/// +/// # See +/// +/// * `xkill`: program pub fn kill_client(conn: &Conn, resource: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { let resource: u32 = resource.into(); - let length_so_far = 0; - let resource_bytes = resource.serialize(); - let mut request0 = [ - KILL_CLIENT_REQUEST, - 0, - 0, - 0, - resource_bytes[0], - resource_bytes[1], - resource_bytes[2], - resource_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = KillClientRequest { + resource, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the RotateProperties request pub const ROTATE_PROPERTIES_REQUEST: u8 = 114; -pub fn rotate_properties<'c, Conn>(conn: &'c Conn, window: Window, delta: i16, atoms: &[Atom]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RotatePropertiesRequest<'input> { + pub window: Window, + pub delta: i16, + pub atoms: &'input [Atom], +} +impl<'input> RotatePropertiesRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let atoms_len = u16::try_from(self.atoms.len()).expect("`atoms` has too many elements"); + let atoms_len_bytes = atoms_len.serialize(); + let delta_bytes = self.delta.serialize(); + let mut request0 = vec![ + ROTATE_PROPERTIES_REQUEST, + 0, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + atoms_len_bytes[0], + atoms_len_bytes[1], + delta_bytes[0], + delta_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let atoms_bytes = self.atoms.serialize(); + let length_so_far = length_so_far + atoms_bytes.len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), atoms_bytes.into(), padding0.into()], vec![])) + } +} +pub fn rotate_properties<'c, 'input, Conn>(conn: &'c Conn, window: Window, delta: i16, atoms: &'input [Atom]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let window_bytes = window.serialize(); - let atoms_len = u16::try_from(atoms.len()).expect("`atoms` has too many elements"); - let atoms_len_bytes = atoms_len.serialize(); - let delta_bytes = delta.serialize(); - let mut request0 = [ - ROTATE_PROPERTIES_REQUEST, - 0, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - atoms_len_bytes[0], - atoms_len_bytes[1], - delta_bytes[0], - delta_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let atoms_bytes = atoms.serialize(); - let length_so_far = length_so_far + atoms_bytes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(&atoms_bytes), IoSlice::new(&padding0)], vec![])?) + let request0 = RotatePropertiesRequest { + window, + delta, + atoms, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -17751,23 +21899,42 @@ impl TryFrom for ScreenSaver { /// Opcode for the ForceScreenSaver request pub const FORCE_SCREEN_SAVER_REQUEST: u8 = 115; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ForceScreenSaverRequest { + pub mode: ScreenSaver, +} +impl ForceScreenSaverRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mode_bytes = u8::from(self.mode).serialize(); + let mut request0 = vec![ + FORCE_SCREEN_SAVER_REQUEST, + mode_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn force_screen_saver(conn: &Conn, mode: ScreenSaver) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mode_bytes = u8::from(mode).serialize(); - let mut request0 = [ - FORCE_SCREEN_SAVER_REQUEST, - mode_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ForceScreenSaverRequest { + mode, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -17837,27 +22004,46 @@ impl TryFrom for MappingStatus { /// Opcode for the SetPointerMapping request pub const SET_POINTER_MAPPING_REQUEST: u8 = 116; -pub fn set_pointer_mapping<'c, Conn>(conn: &'c Conn, map: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetPointerMappingRequest<'input> { + pub map: &'input [u8], +} +impl<'input> SetPointerMappingRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let map_len = u8::try_from(self.map.len()).expect("`map` has too many elements"); + let map_len_bytes = map_len.serialize(); + let mut request0 = vec![ + SET_POINTER_MAPPING_REQUEST, + map_len_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.map[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.map[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_pointer_mapping<'c, 'input, Conn>(conn: &'c Conn, map: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let map_len = u8::try_from(map.len()).expect("`map` has too many elements"); - let map_len_bytes = map_len.serialize(); - let mut request0 = [ - SET_POINTER_MAPPING_REQUEST, - map_len_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + map.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(map), IoSlice::new(&padding0)], vec![])?) + let request0 = SetPointerMappingRequest { + map, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -17887,22 +22073,37 @@ impl TryFrom<&[u8]> for SetPointerMappingReply { /// Opcode for the GetPointerMapping request pub const GET_POINTER_MAPPING_REQUEST: u8 = 117; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPointerMappingRequest; +impl GetPointerMappingRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + GET_POINTER_MAPPING_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_pointer_mapping(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - GET_POINTER_MAPPING_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPointerMappingRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -18029,28 +22230,47 @@ impl TryFrom for MapIndex { /// Opcode for the SetModifierMapping request pub const SET_MODIFIER_MAPPING_REQUEST: u8 = 118; -pub fn set_modifier_mapping<'c, Conn>(conn: &'c Conn, keycodes: &[Keycode]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetModifierMappingRequest<'input> { + pub keycodes: &'input [Keycode], +} +impl<'input> SetModifierMappingRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + assert_eq!(self.keycodes.len() % 8, 0, "`keycodes` has an incorrect length, must be a multiple of 8"); + let keycodes_per_modifier = u8::try_from(self.keycodes.len() / 8).expect("`keycodes` has too many elements"); + let keycodes_per_modifier_bytes = keycodes_per_modifier.serialize(); + let mut request0 = vec![ + SET_MODIFIER_MAPPING_REQUEST, + keycodes_per_modifier_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.keycodes[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.keycodes[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_modifier_mapping<'c, 'input, Conn>(conn: &'c Conn, keycodes: &'input [Keycode]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - assert_eq!(keycodes.len() % 8, 0, "`keycodes` has an incorrect length, must be a multiple of 8"); - let keycodes_per_modifier = u8::try_from(keycodes.len() / 8).expect("`keycodes` has too many elements"); - let keycodes_per_modifier_bytes = keycodes_per_modifier.serialize(); - let mut request0 = [ - SET_MODIFIER_MAPPING_REQUEST, - keycodes_per_modifier_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + keycodes.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0), IoSlice::new(keycodes), IoSlice::new(&padding0)], vec![])?) + let request0 = SetModifierMappingRequest { + keycodes, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -18080,22 +22300,37 @@ impl TryFrom<&[u8]> for SetModifierMappingReply { /// Opcode for the GetModifierMapping request pub const GET_MODIFIER_MAPPING_REQUEST: u8 = 119; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetModifierMappingRequest; +impl GetModifierMappingRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + GET_MODIFIER_MAPPING_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_modifier_mapping(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - GET_MODIFIER_MAPPING_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetModifierMappingRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -18143,22 +22378,37 @@ impl GetModifierMappingReply { /// Opcode for the NoOperation request pub const NO_OPERATION_REQUEST: u8 = 127; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct NoOperationRequest; +impl NoOperationRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let _ = conn; + let length_so_far = 0; + let mut request0 = vec![ + NO_OPERATION_REQUEST, + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn no_operation(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let length_so_far = 0; - let mut request0 = [ - NO_OPERATION_REQUEST, - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = NoOperationRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Extension trait defining the requests of this extension. @@ -18217,7 +22467,7 @@ pub trait ConnectionExt: RequestConnection { /// * `xcb_generate_id`: function /// * `MapWindow`: request /// * `CreateNotify`: event - fn create_window<'c>(&'c self, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: WindowClass, visual: Visualid, value_list: &CreateWindowAux) -> Result, ConnectionError> + fn create_window<'c, 'input>(&'c self, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: WindowClass, visual: Visualid, value_list: &'input CreateWindowAux) -> Result, ConnectionError> { create_window(self, depth, wid, parent, x, y, width, height, border_width, class, visual, value_list) } @@ -18242,7 +22492,7 @@ pub trait ConnectionExt: RequestConnection { /// * `Pixmap` - TODO: reasons? /// * `Value` - TODO: reasons? /// * `Window` - The specified `window` does not exist. - fn change_window_attributes<'c>(&'c self, window: Window, value_list: &ChangeWindowAttributesAux) -> Result, ConnectionError> + fn change_window_attributes<'c, 'input>(&'c self, window: Window, value_list: &'input ChangeWindowAttributesAux) -> Result, ConnectionError> { change_window_attributes(self, window, value_list) } @@ -18476,7 +22726,7 @@ pub trait ConnectionExt: RequestConnection { /// xcb_flush(c); /// } /// ``` - fn configure_window<'c>(&'c self, window: Window, value_list: &ConfigureWindowAux) -> Result, ConnectionError> + fn configure_window<'c, 'input>(&'c self, window: Window, value_list: &'input ConfigureWindowAux) -> Result, ConnectionError> { configure_window(self, window, value_list) } @@ -18627,7 +22877,7 @@ pub trait ConnectionExt: RequestConnection { /// } /// } /// ``` - fn intern_atom<'c>(&'c self, only_if_exists: bool, name: &[u8]) -> Result, ConnectionError> + fn intern_atom<'c, 'input>(&'c self, only_if_exists: bool, name: &'input [u8]) -> Result, ConnectionError> { intern_atom(self, only_if_exists, name) } @@ -18686,7 +22936,7 @@ pub trait ConnectionExt: RequestConnection { /// xcb_flush(conn); /// } /// ``` - fn change_property<'c, A, B>(&'c self, mode: PropMode, window: Window, property: A, type_: B, format: u8, data_len: u32, data: &[u8]) -> Result, ConnectionError> + fn change_property<'c, 'input, A, B>(&'c self, mode: PropMode, window: Window, property: A, type_: B, format: u8, data_len: u32, data: &'input [u8]) -> Result, ConnectionError> where A: Into, B: Into, @@ -19462,7 +23712,7 @@ pub trait ConnectionExt: RequestConnection { /// # See /// /// * `xcb_generate_id`: function - fn open_font<'c>(&'c self, fid: Font, name: &[u8]) -> Result, ConnectionError> + fn open_font<'c, 'input>(&'c self, fid: Font, name: &'input [u8]) -> Result, ConnectionError> { open_font(self, fid, name) } @@ -19515,7 +23765,7 @@ pub trait ConnectionExt: RequestConnection { /// /// * `GContext` - The specified graphics context does not exist. /// * `Font` - The specified `font` does not exist. - fn query_text_extents<'c>(&'c self, font: Fontable, string: &[Char2b]) -> Result, ConnectionError> + fn query_text_extents<'c, 'input>(&'c self, font: Fontable, string: &'input [Char2b]) -> Result, ConnectionError> { query_text_extents(self, font, string) } @@ -19532,7 +23782,7 @@ pub trait ConnectionExt: RequestConnection { /// (?) is a wildcard for a single character. Use of uppercase or lowercase does /// not matter. /// * `max_names` - The maximum number of fonts to be returned. - fn list_fonts<'c>(&'c self, max_names: u16, pattern: &[u8]) -> Result, ConnectionError> + fn list_fonts<'c, 'input>(&'c self, max_names: u16, pattern: &'input [u8]) -> Result, ConnectionError> { list_fonts(self, max_names, pattern) } @@ -19549,11 +23799,11 @@ pub trait ConnectionExt: RequestConnection { /// (?) is a wildcard for a single character. Use of uppercase or lowercase does /// not matter. /// * `max_names` - The maximum number of fonts to be returned. - fn list_fonts_with_info<'c>(&'c self, max_names: u16, pattern: &[u8]) -> Result, ConnectionError> + fn list_fonts_with_info<'c, 'input>(&'c self, max_names: u16, pattern: &'input [u8]) -> Result, ConnectionError> { list_fonts_with_info(self, max_names, pattern) } - fn set_font_path<'c>(&'c self, font: &[Str]) -> Result, ConnectionError> + fn set_font_path<'c, 'input>(&'c self, font: &'input [Str]) -> Result, ConnectionError> { set_font_path(self, font) } @@ -19627,7 +23877,7 @@ pub trait ConnectionExt: RequestConnection { /// # See /// /// * `xcb_generate_id`: function - fn create_gc<'c>(&'c self, cid: Gcontext, drawable: Drawable, value_list: &CreateGCAux) -> Result, ConnectionError> + fn create_gc<'c, 'input>(&'c self, cid: Gcontext, drawable: Drawable, value_list: &'input CreateGCAux) -> Result, ConnectionError> { create_gc(self, cid, drawable, value_list) } @@ -19676,7 +23926,7 @@ pub trait ConnectionExt: RequestConnection { /// xcb_flush(conn); /// } /// ``` - fn change_gc<'c>(&'c self, gc: Gcontext, value_list: &ChangeGCAux) -> Result, ConnectionError> + fn change_gc<'c, 'input>(&'c self, gc: Gcontext, value_list: &'input ChangeGCAux) -> Result, ConnectionError> { change_gc(self, gc, value_list) } @@ -19686,11 +23936,11 @@ pub trait ConnectionExt: RequestConnection { { copy_gc(self, src_gc, dst_gc, value_mask) } - fn set_dashes<'c>(&'c self, gc: Gcontext, dash_offset: u16, dashes: &[u8]) -> Result, ConnectionError> + fn set_dashes<'c, 'input>(&'c self, gc: Gcontext, dash_offset: u16, dashes: &'input [u8]) -> Result, ConnectionError> { set_dashes(self, gc, dash_offset, dashes) } - fn set_clip_rectangles<'c>(&'c self, ordering: ClipOrdering, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles: &[Rectangle]) -> Result, ConnectionError> + fn set_clip_rectangles<'c, 'input>(&'c self, ordering: ClipOrdering, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles: &'input [Rectangle]) -> Result, ConnectionError> { set_clip_rectangles(self, ordering, gc, clip_x_origin, clip_y_origin, rectangles) } @@ -19742,7 +23992,7 @@ pub trait ConnectionExt: RequestConnection { { copy_plane(self, src_drawable, dst_drawable, gc, src_x, src_y, dst_x, dst_y, width, height, bit_plane) } - fn poly_point<'c>(&'c self, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &[Point]) -> Result, ConnectionError> + fn poly_point<'c, 'input>(&'c self, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &'input [Point]) -> Result, ConnectionError> { poly_point(self, coordinate_mode, drawable, gc, points) } @@ -19785,7 +24035,7 @@ pub trait ConnectionExt: RequestConnection { /// xcb_flush(conn); /// } /// ``` - fn poly_line<'c>(&'c self, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &[Point]) -> Result, ConnectionError> + fn poly_line<'c, 'input>(&'c self, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &'input [Point]) -> Result, ConnectionError> { poly_line(self, coordinate_mode, drawable, gc, points) } @@ -19815,19 +24065,19 @@ pub trait ConnectionExt: RequestConnection { /// * `Drawable` - The specified `drawable` does not exist. /// * `GContext` - The specified `gc` does not exist. /// * `Match` - TODO: reasons? - fn poly_segment<'c>(&'c self, drawable: Drawable, gc: Gcontext, segments: &[Segment]) -> Result, ConnectionError> + fn poly_segment<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, segments: &'input [Segment]) -> Result, ConnectionError> { poly_segment(self, drawable, gc, segments) } - fn poly_rectangle<'c>(&'c self, drawable: Drawable, gc: Gcontext, rectangles: &[Rectangle]) -> Result, ConnectionError> + fn poly_rectangle<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, rectangles: &'input [Rectangle]) -> Result, ConnectionError> { poly_rectangle(self, drawable, gc, rectangles) } - fn poly_arc<'c>(&'c self, drawable: Drawable, gc: Gcontext, arcs: &[Arc]) -> Result, ConnectionError> + fn poly_arc<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, arcs: &'input [Arc]) -> Result, ConnectionError> { poly_arc(self, drawable, gc, arcs) } - fn fill_poly<'c>(&'c self, drawable: Drawable, gc: Gcontext, shape: PolyShape, coordinate_mode: CoordMode, points: &[Point]) -> Result, ConnectionError> + fn fill_poly<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, shape: PolyShape, coordinate_mode: CoordMode, points: &'input [Point]) -> Result, ConnectionError> { fill_poly(self, drawable, gc, shape, coordinate_mode, points) } @@ -19856,15 +24106,15 @@ pub trait ConnectionExt: RequestConnection { /// * `Drawable` - The specified `drawable` (Window or Pixmap) does not exist. /// * `GContext` - The specified graphics context does not exist. /// * `Match` - TODO: reasons? - fn poly_fill_rectangle<'c>(&'c self, drawable: Drawable, gc: Gcontext, rectangles: &[Rectangle]) -> Result, ConnectionError> + fn poly_fill_rectangle<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, rectangles: &'input [Rectangle]) -> Result, ConnectionError> { poly_fill_rectangle(self, drawable, gc, rectangles) } - fn poly_fill_arc<'c>(&'c self, drawable: Drawable, gc: Gcontext, arcs: &[Arc]) -> Result, ConnectionError> + fn poly_fill_arc<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, arcs: &'input [Arc]) -> Result, ConnectionError> { poly_fill_arc(self, drawable, gc, arcs) } - fn put_image<'c>(&'c self, format: ImageFormat, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data: &[u8]) -> Result, ConnectionError> + fn put_image<'c, 'input>(&'c self, format: ImageFormat, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data: &'input [u8]) -> Result, ConnectionError> { put_image(self, format, drawable, gc, width, height, dst_x, dst_y, left_pad, depth, data) } @@ -19872,11 +24122,11 @@ pub trait ConnectionExt: RequestConnection { { get_image(self, format, drawable, x, y, width, height, plane_mask) } - fn poly_text8<'c>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &[u8]) -> Result, ConnectionError> + fn poly_text8<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &'input [u8]) -> Result, ConnectionError> { poly_text8(self, drawable, gc, x, y, items) } - fn poly_text16<'c>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &[u8]) -> Result, ConnectionError> + fn poly_text16<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &'input [u8]) -> Result, ConnectionError> { poly_text16(self, drawable, gc, x, y, items) } @@ -19914,7 +24164,7 @@ pub trait ConnectionExt: RequestConnection { /// # See /// /// * `ImageText16`: request - fn image_text8<'c>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &[u8]) -> Result, ConnectionError> + fn image_text8<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &'input [u8]) -> Result, ConnectionError> { image_text8(self, drawable, gc, x, y, string) } @@ -19953,7 +24203,7 @@ pub trait ConnectionExt: RequestConnection { /// # See /// /// * `ImageText8`: request - fn image_text16<'c>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &[Char2b]) -> Result, ConnectionError> + fn image_text16<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &'input [Char2b]) -> Result, ConnectionError> { image_text16(self, drawable, gc, x, y, string) } @@ -20003,7 +24253,7 @@ pub trait ConnectionExt: RequestConnection { { alloc_color(self, cmap, red, green, blue) } - fn alloc_named_color<'c>(&'c self, cmap: Colormap, name: &[u8]) -> Result, ConnectionError> + fn alloc_named_color<'c, 'input>(&'c self, cmap: Colormap, name: &'input [u8]) -> Result, ConnectionError> { alloc_named_color(self, cmap, name) } @@ -20015,25 +24265,25 @@ pub trait ConnectionExt: RequestConnection { { alloc_color_planes(self, contiguous, cmap, colors, reds, greens, blues) } - fn free_colors<'c>(&'c self, cmap: Colormap, plane_mask: u32, pixels: &[u32]) -> Result, ConnectionError> + fn free_colors<'c, 'input>(&'c self, cmap: Colormap, plane_mask: u32, pixels: &'input [u32]) -> Result, ConnectionError> { free_colors(self, cmap, plane_mask, pixels) } - fn store_colors<'c>(&'c self, cmap: Colormap, items: &[Coloritem]) -> Result, ConnectionError> + fn store_colors<'c, 'input>(&'c self, cmap: Colormap, items: &'input [Coloritem]) -> Result, ConnectionError> { store_colors(self, cmap, items) } - fn store_named_color<'c, A>(&'c self, flags: A, cmap: Colormap, pixel: u32, name: &[u8]) -> Result, ConnectionError> + fn store_named_color<'c, 'input, A>(&'c self, flags: A, cmap: Colormap, pixel: u32, name: &'input [u8]) -> Result, ConnectionError> where A: Into, { store_named_color(self, flags, cmap, pixel, name) } - fn query_colors<'c>(&'c self, cmap: Colormap, pixels: &[u32]) -> Result, ConnectionError> + fn query_colors<'c, 'input>(&'c self, cmap: Colormap, pixels: &'input [u32]) -> Result, ConnectionError> { query_colors(self, cmap, pixels) } - fn lookup_color<'c>(&'c self, cmap: Colormap, name: &[u8]) -> Result, ConnectionError> + fn lookup_color<'c, 'input>(&'c self, cmap: Colormap, name: &'input [u8]) -> Result, ConnectionError> { lookup_color(self, cmap, name) } @@ -20128,7 +24378,7 @@ pub trait ConnectionExt: RequestConnection { /// /// * `xdpyinfo`: program /// * `xcb_get_extension_data`: function - fn query_extension<'c>(&'c self, name: &[u8]) -> Result, ConnectionError> + fn query_extension<'c, 'input>(&'c self, name: &'input [u8]) -> Result, ConnectionError> { query_extension(self, name) } @@ -20136,7 +24386,7 @@ pub trait ConnectionExt: RequestConnection { { list_extensions(self) } - fn change_keyboard_mapping<'c>(&'c self, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: &[Keysym]) -> Result, ConnectionError> + fn change_keyboard_mapping<'c, 'input>(&'c self, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: &'input [Keysym]) -> Result, ConnectionError> { change_keyboard_mapping(self, keycode_count, first_keycode, keysyms_per_keycode, keysyms) } @@ -20144,7 +24394,7 @@ pub trait ConnectionExt: RequestConnection { { get_keyboard_mapping(self, first_keycode, count) } - fn change_keyboard_control<'c>(&'c self, value_list: &ChangeKeyboardControlAux) -> Result, ConnectionError> + fn change_keyboard_control<'c, 'input>(&'c self, value_list: &'input ChangeKeyboardControlAux) -> Result, ConnectionError> { change_keyboard_control(self, value_list) } @@ -20172,7 +24422,7 @@ pub trait ConnectionExt: RequestConnection { { get_screen_saver(self) } - fn change_hosts<'c>(&'c self, mode: HostMode, family: Family, address: &[u8]) -> Result, ConnectionError> + fn change_hosts<'c, 'input>(&'c self, mode: HostMode, family: Family, address: &'input [u8]) -> Result, ConnectionError> { change_hosts(self, mode, family, address) } @@ -20213,7 +24463,7 @@ pub trait ConnectionExt: RequestConnection { { kill_client(self, resource) } - fn rotate_properties<'c>(&'c self, window: Window, delta: i16, atoms: &[Atom]) -> Result, ConnectionError> + fn rotate_properties<'c, 'input>(&'c self, window: Window, delta: i16, atoms: &'input [Atom]) -> Result, ConnectionError> { rotate_properties(self, window, delta, atoms) } @@ -20221,7 +24471,7 @@ pub trait ConnectionExt: RequestConnection { { force_screen_saver(self, mode) } - fn set_pointer_mapping<'c>(&'c self, map: &[u8]) -> Result, ConnectionError> + fn set_pointer_mapping<'c, 'input>(&'c self, map: &'input [u8]) -> Result, ConnectionError> { set_pointer_mapping(self, map) } @@ -20229,7 +24479,7 @@ pub trait ConnectionExt: RequestConnection { { get_pointer_mapping(self) } - fn set_modifier_mapping<'c>(&'c self, keycodes: &[Keycode]) -> Result, ConnectionError> + fn set_modifier_mapping<'c, 'input>(&'c self, keycodes: &'input [Keycode]) -> Result, ConnectionError> { set_modifier_mapping(self, keycodes) } diff --git a/src/protocol/xselinux.rs b/src/protocol/xselinux.rs index d8e53b71..cdbd811c 100644 --- a/src/protocol/xselinux.rs +++ b/src/protocol/xselinux.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -35,30 +35,50 @@ pub const X11_XML_VERSION: (u32, u32) = (1, 0); /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest { + pub client_major: u8, + pub client_minor: u8, +} +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let client_major_bytes = self.client_major.serialize(); + let client_minor_bytes = self.client_minor.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + client_major_bytes[0], + client_minor_bytes[0], + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn, client_major: u8, client_minor: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let client_major_bytes = client_major.serialize(); - let client_minor_bytes = client_minor.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - client_major_bytes[0], - client_minor_bytes[0], - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest { + client_major, + client_minor, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -90,55 +110,87 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the SetDeviceCreateContext request pub const SET_DEVICE_CREATE_CONTEXT_REQUEST: u8 = 1; -pub fn set_device_create_context<'c, Conn>(conn: &'c Conn, context: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetDeviceCreateContextRequest<'input> { + pub context: &'input [u8], +} +impl<'input> SetDeviceCreateContextRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_len = u32::try_from(self.context.len()).expect("`context` has too many elements"); + let context_len_bytes = context_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_DEVICE_CREATE_CONTEXT_REQUEST, + 0, + 0, + context_len_bytes[0], + context_len_bytes[1], + context_len_bytes[2], + context_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.context[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.context[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_device_create_context<'c, 'input, Conn>(conn: &'c Conn, context: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_len = u32::try_from(context.len()).expect("`context` has too many elements"); - let context_len_bytes = context_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_DEVICE_CREATE_CONTEXT_REQUEST, - 0, - 0, - context_len_bytes[0], - context_len_bytes[1], - context_len_bytes[2], - context_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + context.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(context), IoSlice::new(&padding0)], vec![])?) + let request0 = SetDeviceCreateContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetDeviceCreateContext request pub const GET_DEVICE_CREATE_CONTEXT_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceCreateContextRequest; +impl GetDeviceCreateContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_CREATE_CONTEXT_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_create_context(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_CREATE_CONTEXT_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceCreateContextRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -186,65 +238,103 @@ impl GetDeviceCreateContextReply { /// Opcode for the SetDeviceContext request pub const SET_DEVICE_CONTEXT_REQUEST: u8 = 3; -pub fn set_device_context<'c, Conn>(conn: &'c Conn, device: u32, context: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetDeviceContextRequest<'input> { + pub device: u32, + pub context: &'input [u8], +} +impl<'input> SetDeviceContextRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_bytes = self.device.serialize(); + let context_len = u32::try_from(self.context.len()).expect("`context` has too many elements"); + let context_len_bytes = context_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_DEVICE_CONTEXT_REQUEST, + 0, + 0, + device_bytes[0], + device_bytes[1], + device_bytes[2], + device_bytes[3], + context_len_bytes[0], + context_len_bytes[1], + context_len_bytes[2], + context_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.context[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.context[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_device_context<'c, 'input, Conn>(conn: &'c Conn, device: u32, context: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_bytes = device.serialize(); - let context_len = u32::try_from(context.len()).expect("`context` has too many elements"); - let context_len_bytes = context_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_DEVICE_CONTEXT_REQUEST, - 0, - 0, - device_bytes[0], - device_bytes[1], - device_bytes[2], - device_bytes[3], - context_len_bytes[0], - context_len_bytes[1], - context_len_bytes[2], - context_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + context.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(context), IoSlice::new(&padding0)], vec![])?) + let request0 = SetDeviceContextRequest { + device, + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetDeviceContext request pub const GET_DEVICE_CONTEXT_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetDeviceContextRequest { + pub device: u32, +} +impl GetDeviceContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let device_bytes = self.device.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_DEVICE_CONTEXT_REQUEST, + 0, + 0, + device_bytes[0], + device_bytes[1], + device_bytes[2], + device_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_device_context(conn: &Conn, device: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let device_bytes = device.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_DEVICE_CONTEXT_REQUEST, - 0, - 0, - device_bytes[0], - device_bytes[1], - device_bytes[2], - device_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetDeviceContextRequest { + device, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -292,55 +382,87 @@ impl GetDeviceContextReply { /// Opcode for the SetWindowCreateContext request pub const SET_WINDOW_CREATE_CONTEXT_REQUEST: u8 = 5; -pub fn set_window_create_context<'c, Conn>(conn: &'c Conn, context: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetWindowCreateContextRequest<'input> { + pub context: &'input [u8], +} +impl<'input> SetWindowCreateContextRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_len = u32::try_from(self.context.len()).expect("`context` has too many elements"); + let context_len_bytes = context_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_WINDOW_CREATE_CONTEXT_REQUEST, + 0, + 0, + context_len_bytes[0], + context_len_bytes[1], + context_len_bytes[2], + context_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.context[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.context[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_window_create_context<'c, 'input, Conn>(conn: &'c Conn, context: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_len = u32::try_from(context.len()).expect("`context` has too many elements"); - let context_len_bytes = context_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_WINDOW_CREATE_CONTEXT_REQUEST, - 0, - 0, - context_len_bytes[0], - context_len_bytes[1], - context_len_bytes[2], - context_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + context.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(context), IoSlice::new(&padding0)], vec![])?) + let request0 = SetWindowCreateContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetWindowCreateContext request pub const GET_WINDOW_CREATE_CONTEXT_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetWindowCreateContextRequest; +impl GetWindowCreateContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + GET_WINDOW_CREATE_CONTEXT_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_window_create_context(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - GET_WINDOW_CREATE_CONTEXT_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetWindowCreateContextRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -388,29 +510,47 @@ impl GetWindowCreateContextReply { /// Opcode for the GetWindowContext request pub const GET_WINDOW_CONTEXT_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetWindowContextRequest { + pub window: xproto::Window, +} +impl GetWindowContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_WINDOW_CONTEXT_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_window_context(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_WINDOW_CONTEXT_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetWindowContextRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -541,55 +681,87 @@ impl ListItem { /// Opcode for the SetPropertyCreateContext request pub const SET_PROPERTY_CREATE_CONTEXT_REQUEST: u8 = 8; -pub fn set_property_create_context<'c, Conn>(conn: &'c Conn, context: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetPropertyCreateContextRequest<'input> { + pub context: &'input [u8], +} +impl<'input> SetPropertyCreateContextRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_len = u32::try_from(self.context.len()).expect("`context` has too many elements"); + let context_len_bytes = context_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PROPERTY_CREATE_CONTEXT_REQUEST, + 0, + 0, + context_len_bytes[0], + context_len_bytes[1], + context_len_bytes[2], + context_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.context[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.context[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_property_create_context<'c, 'input, Conn>(conn: &'c Conn, context: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_len = u32::try_from(context.len()).expect("`context` has too many elements"); - let context_len_bytes = context_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PROPERTY_CREATE_CONTEXT_REQUEST, - 0, - 0, - context_len_bytes[0], - context_len_bytes[1], - context_len_bytes[2], - context_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + context.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(context), IoSlice::new(&padding0)], vec![])?) + let request0 = SetPropertyCreateContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetPropertyCreateContext request pub const GET_PROPERTY_CREATE_CONTEXT_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPropertyCreateContextRequest; +impl GetPropertyCreateContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + GET_PROPERTY_CREATE_CONTEXT_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_property_create_context(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - GET_PROPERTY_CREATE_CONTEXT_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPropertyCreateContextRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -637,55 +809,87 @@ impl GetPropertyCreateContextReply { /// Opcode for the SetPropertyUseContext request pub const SET_PROPERTY_USE_CONTEXT_REQUEST: u8 = 10; -pub fn set_property_use_context<'c, Conn>(conn: &'c Conn, context: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetPropertyUseContextRequest<'input> { + pub context: &'input [u8], +} +impl<'input> SetPropertyUseContextRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_len = u32::try_from(self.context.len()).expect("`context` has too many elements"); + let context_len_bytes = context_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PROPERTY_USE_CONTEXT_REQUEST, + 0, + 0, + context_len_bytes[0], + context_len_bytes[1], + context_len_bytes[2], + context_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.context[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.context[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_property_use_context<'c, 'input, Conn>(conn: &'c Conn, context: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_len = u32::try_from(context.len()).expect("`context` has too many elements"); - let context_len_bytes = context_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PROPERTY_USE_CONTEXT_REQUEST, - 0, - 0, - context_len_bytes[0], - context_len_bytes[1], - context_len_bytes[2], - context_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + context.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(context), IoSlice::new(&padding0)], vec![])?) + let request0 = SetPropertyUseContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetPropertyUseContext request pub const GET_PROPERTY_USE_CONTEXT_REQUEST: u8 = 11; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPropertyUseContextRequest; +impl GetPropertyUseContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + GET_PROPERTY_USE_CONTEXT_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_property_use_context(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - GET_PROPERTY_USE_CONTEXT_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPropertyUseContextRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -733,34 +937,54 @@ impl GetPropertyUseContextReply { /// Opcode for the GetPropertyContext request pub const GET_PROPERTY_CONTEXT_REQUEST: u8 = 12; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPropertyContextRequest { + pub window: xproto::Window, + pub property: xproto::Atom, +} +impl GetPropertyContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let property_bytes = self.property.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PROPERTY_CONTEXT_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_property_context(conn: &Conn, window: xproto::Window, property: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let property_bytes = property.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PROPERTY_CONTEXT_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPropertyContextRequest { + window, + property, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -808,34 +1032,54 @@ impl GetPropertyContextReply { /// Opcode for the GetPropertyDataContext request pub const GET_PROPERTY_DATA_CONTEXT_REQUEST: u8 = 13; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPropertyDataContextRequest { + pub window: xproto::Window, + pub property: xproto::Atom, +} +impl GetPropertyDataContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let property_bytes = self.property.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PROPERTY_DATA_CONTEXT_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + property_bytes[0], + property_bytes[1], + property_bytes[2], + property_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_property_data_context(conn: &Conn, window: xproto::Window, property: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let property_bytes = property.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PROPERTY_DATA_CONTEXT_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - property_bytes[0], - property_bytes[1], - property_bytes[2], - property_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPropertyDataContextRequest { + window, + property, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -883,29 +1127,47 @@ impl GetPropertyDataContextReply { /// Opcode for the ListProperties request pub const LIST_PROPERTIES_REQUEST: u8 = 14; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListPropertiesRequest { + pub window: xproto::Window, +} +impl ListPropertiesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + LIST_PROPERTIES_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_properties(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - LIST_PROPERTIES_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListPropertiesRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -952,55 +1214,87 @@ impl ListPropertiesReply { /// Opcode for the SetSelectionCreateContext request pub const SET_SELECTION_CREATE_CONTEXT_REQUEST: u8 = 15; -pub fn set_selection_create_context<'c, Conn>(conn: &'c Conn, context: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetSelectionCreateContextRequest<'input> { + pub context: &'input [u8], +} +impl<'input> SetSelectionCreateContextRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_len = u32::try_from(self.context.len()).expect("`context` has too many elements"); + let context_len_bytes = context_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_SELECTION_CREATE_CONTEXT_REQUEST, + 0, + 0, + context_len_bytes[0], + context_len_bytes[1], + context_len_bytes[2], + context_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.context[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.context[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_selection_create_context<'c, 'input, Conn>(conn: &'c Conn, context: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_len = u32::try_from(context.len()).expect("`context` has too many elements"); - let context_len_bytes = context_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_SELECTION_CREATE_CONTEXT_REQUEST, - 0, - 0, - context_len_bytes[0], - context_len_bytes[1], - context_len_bytes[2], - context_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + context.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(context), IoSlice::new(&padding0)], vec![])?) + let request0 = SetSelectionCreateContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetSelectionCreateContext request pub const GET_SELECTION_CREATE_CONTEXT_REQUEST: u8 = 16; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetSelectionCreateContextRequest; +impl GetSelectionCreateContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + GET_SELECTION_CREATE_CONTEXT_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_selection_create_context(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - GET_SELECTION_CREATE_CONTEXT_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetSelectionCreateContextRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1048,55 +1342,87 @@ impl GetSelectionCreateContextReply { /// Opcode for the SetSelectionUseContext request pub const SET_SELECTION_USE_CONTEXT_REQUEST: u8 = 17; -pub fn set_selection_use_context<'c, Conn>(conn: &'c Conn, context: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SetSelectionUseContextRequest<'input> { + pub context: &'input [u8], +} +impl<'input> SetSelectionUseContextRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_len = u32::try_from(self.context.len()).expect("`context` has too many elements"); + let context_len_bytes = context_len.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_SELECTION_USE_CONTEXT_REQUEST, + 0, + 0, + context_len_bytes[0], + context_len_bytes[1], + context_len_bytes[2], + context_len_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.context[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.context[..]).into(), padding0.into()], vec![])) + } +} +pub fn set_selection_use_context<'c, 'input, Conn>(conn: &'c Conn, context: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_len = u32::try_from(context.len()).expect("`context` has too many elements"); - let context_len_bytes = context_len.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_SELECTION_USE_CONTEXT_REQUEST, - 0, - 0, - context_len_bytes[0], - context_len_bytes[1], - context_len_bytes[2], - context_len_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + context.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(context), IoSlice::new(&padding0)], vec![])?) + let request0 = SetSelectionUseContextRequest { + context, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetSelectionUseContext request pub const GET_SELECTION_USE_CONTEXT_REQUEST: u8 = 18; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetSelectionUseContextRequest; +impl GetSelectionUseContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + GET_SELECTION_USE_CONTEXT_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_selection_use_context(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - GET_SELECTION_USE_CONTEXT_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetSelectionUseContextRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1144,29 +1470,47 @@ impl GetSelectionUseContextReply { /// Opcode for the GetSelectionContext request pub const GET_SELECTION_CONTEXT_REQUEST: u8 = 19; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetSelectionContextRequest { + pub selection: xproto::Atom, +} +impl GetSelectionContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let selection_bytes = self.selection.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SELECTION_CONTEXT_REQUEST, + 0, + 0, + selection_bytes[0], + selection_bytes[1], + selection_bytes[2], + selection_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_selection_context(conn: &Conn, selection: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let selection_bytes = selection.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SELECTION_CONTEXT_REQUEST, - 0, - 0, - selection_bytes[0], - selection_bytes[1], - selection_bytes[2], - selection_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetSelectionContextRequest { + selection, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1214,29 +1558,47 @@ impl GetSelectionContextReply { /// Opcode for the GetSelectionDataContext request pub const GET_SELECTION_DATA_CONTEXT_REQUEST: u8 = 20; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetSelectionDataContextRequest { + pub selection: xproto::Atom, +} +impl GetSelectionDataContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let selection_bytes = self.selection.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_SELECTION_DATA_CONTEXT_REQUEST, + 0, + 0, + selection_bytes[0], + selection_bytes[1], + selection_bytes[2], + selection_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_selection_data_context(conn: &Conn, selection: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let selection_bytes = selection.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_SELECTION_DATA_CONTEXT_REQUEST, - 0, - 0, - selection_bytes[0], - selection_bytes[1], - selection_bytes[2], - selection_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetSelectionDataContextRequest { + selection, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1284,24 +1646,38 @@ impl GetSelectionDataContextReply { /// Opcode for the ListSelections request pub const LIST_SELECTIONS_REQUEST: u8 = 21; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListSelectionsRequest; +impl ListSelectionsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + LIST_SELECTIONS_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_selections(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - LIST_SELECTIONS_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListSelectionsRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1348,29 +1724,47 @@ impl ListSelectionsReply { /// Opcode for the GetClientContext request pub const GET_CLIENT_CONTEXT_REQUEST: u8 = 22; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetClientContextRequest { + pub resource: u32, +} +impl GetClientContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let resource_bytes = self.resource.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_CLIENT_CONTEXT_REQUEST, + 0, + 0, + resource_bytes[0], + resource_bytes[1], + resource_bytes[2], + resource_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_client_context(conn: &Conn, resource: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let resource_bytes = resource.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_CLIENT_CONTEXT_REQUEST, - 0, - 0, - resource_bytes[0], - resource_bytes[1], - resource_bytes[2], - resource_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetClientContextRequest { + resource, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1422,7 +1816,7 @@ pub trait ConnectionExt: RequestConnection { { query_version(self, client_major, client_minor) } - fn xselinux_set_device_create_context<'c>(&'c self, context: &[u8]) -> Result, ConnectionError> + fn xselinux_set_device_create_context<'c, 'input>(&'c self, context: &'input [u8]) -> Result, ConnectionError> { set_device_create_context(self, context) } @@ -1430,7 +1824,7 @@ pub trait ConnectionExt: RequestConnection { { get_device_create_context(self) } - fn xselinux_set_device_context<'c>(&'c self, device: u32, context: &[u8]) -> Result, ConnectionError> + fn xselinux_set_device_context<'c, 'input>(&'c self, device: u32, context: &'input [u8]) -> Result, ConnectionError> { set_device_context(self, device, context) } @@ -1438,7 +1832,7 @@ pub trait ConnectionExt: RequestConnection { { get_device_context(self, device) } - fn xselinux_set_window_create_context<'c>(&'c self, context: &[u8]) -> Result, ConnectionError> + fn xselinux_set_window_create_context<'c, 'input>(&'c self, context: &'input [u8]) -> Result, ConnectionError> { set_window_create_context(self, context) } @@ -1450,7 +1844,7 @@ pub trait ConnectionExt: RequestConnection { { get_window_context(self, window) } - fn xselinux_set_property_create_context<'c>(&'c self, context: &[u8]) -> Result, ConnectionError> + fn xselinux_set_property_create_context<'c, 'input>(&'c self, context: &'input [u8]) -> Result, ConnectionError> { set_property_create_context(self, context) } @@ -1458,7 +1852,7 @@ pub trait ConnectionExt: RequestConnection { { get_property_create_context(self) } - fn xselinux_set_property_use_context<'c>(&'c self, context: &[u8]) -> Result, ConnectionError> + fn xselinux_set_property_use_context<'c, 'input>(&'c self, context: &'input [u8]) -> Result, ConnectionError> { set_property_use_context(self, context) } @@ -1478,7 +1872,7 @@ pub trait ConnectionExt: RequestConnection { { list_properties(self, window) } - fn xselinux_set_selection_create_context<'c>(&'c self, context: &[u8]) -> Result, ConnectionError> + fn xselinux_set_selection_create_context<'c, 'input>(&'c self, context: &'input [u8]) -> Result, ConnectionError> { set_selection_create_context(self, context) } @@ -1486,7 +1880,7 @@ pub trait ConnectionExt: RequestConnection { { get_selection_create_context(self) } - fn xselinux_set_selection_use_context<'c>(&'c self, context: &[u8]) -> Result, ConnectionError> + fn xselinux_set_selection_use_context<'c, 'input>(&'c self, context: &'input [u8]) -> Result, ConnectionError> { set_selection_use_context(self, context) } diff --git a/src/protocol/xtest.rs b/src/protocol/xtest.rs index f51c33a0..894c754e 100644 --- a/src/protocol/xtest.rs +++ b/src/protocol/xtest.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -35,30 +35,50 @@ pub const X11_XML_VERSION: (u32, u32) = (2, 2); /// Opcode for the GetVersion request pub const GET_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetVersionRequest { + pub major_version: u8, + pub minor_version: u16, +} +impl GetVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let major_version_bytes = self.major_version.serialize(); + let minor_version_bytes = self.minor_version.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_VERSION_REQUEST, + 0, + 0, + major_version_bytes[0], + 0, + minor_version_bytes[0], + minor_version_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_version(conn: &Conn, major_version: u8, minor_version: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let major_version_bytes = major_version.serialize(); - let minor_version_bytes = minor_version.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_VERSION_REQUEST, - 0, - 0, - major_version_bytes[0], - 0, - minor_version_bytes[0], - minor_version_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetVersionRequest { + major_version, + minor_version, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -159,34 +179,54 @@ impl TryFrom for Cursor { /// Opcode for the CompareCursor request pub const COMPARE_CURSOR_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CompareCursorRequest { + pub window: xproto::Window, + pub cursor: xproto::Cursor, +} +impl CompareCursorRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let cursor_bytes = self.cursor.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + COMPARE_CURSOR_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + cursor_bytes[0], + cursor_bytes[1], + cursor_bytes[2], + cursor_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn compare_cursor(conn: &Conn, window: xproto::Window, cursor: xproto::Cursor) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let cursor_bytes = cursor.serialize(); - let mut request0 = [ - extension_information.major_opcode, - COMPARE_CURSOR_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - cursor_bytes[0], - cursor_bytes[1], - cursor_bytes[2], - cursor_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CompareCursorRequest { + window, + cursor, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -215,90 +255,138 @@ impl TryFrom<&[u8]> for CompareCursorReply { /// Opcode for the FakeInput request pub const FAKE_INPUT_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FakeInputRequest { + pub type_: u8, + pub detail: u8, + pub time: u32, + pub root: xproto::Window, + pub root_x: i16, + pub root_y: i16, + pub deviceid: u8, +} +impl FakeInputRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let type_bytes = self.type_.serialize(); + let detail_bytes = self.detail.serialize(); + let time_bytes = self.time.serialize(); + let root_bytes = self.root.serialize(); + let root_x_bytes = self.root_x.serialize(); + let root_y_bytes = self.root_y.serialize(); + let deviceid_bytes = self.deviceid.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + FAKE_INPUT_REQUEST, + 0, + 0, + type_bytes[0], + detail_bytes[0], + 0, + 0, + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + root_bytes[0], + root_bytes[1], + root_bytes[2], + root_bytes[3], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + root_x_bytes[0], + root_x_bytes[1], + root_y_bytes[0], + root_y_bytes[1], + 0, + 0, + 0, + 0, + 0, + 0, + 0, + deviceid_bytes[0], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn fake_input(conn: &Conn, type_: u8, detail: u8, time: u32, root: xproto::Window, root_x: i16, root_y: i16, deviceid: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let type_bytes = type_.serialize(); - let detail_bytes = detail.serialize(); - let time_bytes = time.serialize(); - let root_bytes = root.serialize(); - let root_x_bytes = root_x.serialize(); - let root_y_bytes = root_y.serialize(); - let deviceid_bytes = deviceid.serialize(); - let mut request0 = [ - extension_information.major_opcode, - FAKE_INPUT_REQUEST, - 0, - 0, - type_bytes[0], - detail_bytes[0], - 0, - 0, - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - root_bytes[0], - root_bytes[1], - root_bytes[2], - root_bytes[3], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - root_x_bytes[0], - root_x_bytes[1], - root_y_bytes[0], - root_y_bytes[1], - 0, - 0, - 0, - 0, - 0, - 0, - 0, - deviceid_bytes[0], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = FakeInputRequest { + type_, + detail, + time, + root, + root_x, + root_y, + deviceid, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GrabControl request pub const GRAB_CONTROL_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GrabControlRequest { + pub impervious: bool, +} +impl GrabControlRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let impervious_bytes = self.impervious.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GRAB_CONTROL_REQUEST, + 0, + 0, + impervious_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn grab_control(conn: &Conn, impervious: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let impervious_bytes = impervious.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GRAB_CONTROL_REQUEST, - 0, - 0, - impervious_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GrabControlRequest { + impervious, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Extension trait defining the requests of this extension. diff --git a/src/protocol/xv.rs b/src/protocol/xv.rs index 999e0d4d..173a3e05 100644 --- a/src/protocol/xv.rs +++ b/src/protocol/xv.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -1547,24 +1547,38 @@ impl From for [u8; 32] { /// Opcode for the QueryExtension request pub const QUERY_EXTENSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryExtensionRequest; +impl QueryExtensionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_EXTENSION_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_extension(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - QUERY_EXTENSION_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryExtensionRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1596,29 +1610,47 @@ impl TryFrom<&[u8]> for QueryExtensionReply { /// Opcode for the QueryAdaptors request pub const QUERY_ADAPTORS_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryAdaptorsRequest { + pub window: xproto::Window, +} +impl QueryAdaptorsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let window_bytes = self.window.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_ADAPTORS_REQUEST, + 0, + 0, + window_bytes[0], + window_bytes[1], + window_bytes[2], + window_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_adaptors(conn: &Conn, window: xproto::Window) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let window_bytes = window.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_ADAPTORS_REQUEST, - 0, - 0, - window_bytes[0], - window_bytes[1], - window_bytes[2], - window_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryAdaptorsRequest { + window, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1665,29 +1697,47 @@ impl QueryAdaptorsReply { /// Opcode for the QueryEncodings request pub const QUERY_ENCODINGS_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryEncodingsRequest { + pub port: Port, +} +impl QueryEncodingsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_ENCODINGS_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_encodings(conn: &Conn, port: Port) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_ENCODINGS_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryEncodingsRequest { + port, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -1734,36 +1784,56 @@ impl QueryEncodingsReply { /// Opcode for the GrabPort request pub const GRAB_PORT_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GrabPortRequest { + pub port: Port, + pub time: xproto::Timestamp, +} +impl GrabPortRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let time_bytes = self.time.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GRAB_PORT_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn grab_port(conn: &Conn, port: Port, time: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let time: xproto::Timestamp = time.into(); - let length_so_far = 0; - let port_bytes = port.serialize(); - let time_bytes = time.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GRAB_PORT_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GrabPortRequest { + port, + time, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -1793,420 +1863,680 @@ impl TryFrom<&[u8]> for GrabPortReply { /// Opcode for the UngrabPort request pub const UNGRAB_PORT_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UngrabPortRequest { + pub port: Port, + pub time: xproto::Timestamp, +} +impl UngrabPortRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let time_bytes = self.time.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + UNGRAB_PORT_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + time_bytes[0], + time_bytes[1], + time_bytes[2], + time_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn ungrab_port(conn: &Conn, port: Port, time: A) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, A: Into, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; let time: xproto::Timestamp = time.into(); - let length_so_far = 0; - let port_bytes = port.serialize(); - let time_bytes = time.serialize(); - let mut request0 = [ - extension_information.major_opcode, - UNGRAB_PORT_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - time_bytes[0], - time_bytes[1], - time_bytes[2], - time_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = UngrabPortRequest { + port, + time, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PutVideo request pub const PUT_VIDEO_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PutVideoRequest { + pub port: Port, + pub drawable: xproto::Drawable, + pub gc: xproto::Gcontext, + pub vid_x: i16, + pub vid_y: i16, + pub vid_w: u16, + pub vid_h: u16, + pub drw_x: i16, + pub drw_y: i16, + pub drw_w: u16, + pub drw_h: u16, +} +impl PutVideoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let vid_x_bytes = self.vid_x.serialize(); + let vid_y_bytes = self.vid_y.serialize(); + let vid_w_bytes = self.vid_w.serialize(); + let vid_h_bytes = self.vid_h.serialize(); + let drw_x_bytes = self.drw_x.serialize(); + let drw_y_bytes = self.drw_y.serialize(); + let drw_w_bytes = self.drw_w.serialize(); + let drw_h_bytes = self.drw_h.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PUT_VIDEO_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + vid_x_bytes[0], + vid_x_bytes[1], + vid_y_bytes[0], + vid_y_bytes[1], + vid_w_bytes[0], + vid_w_bytes[1], + vid_h_bytes[0], + vid_h_bytes[1], + drw_x_bytes[0], + drw_x_bytes[1], + drw_y_bytes[0], + drw_y_bytes[1], + drw_w_bytes[0], + drw_w_bytes[1], + drw_h_bytes[0], + drw_h_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn put_video(conn: &Conn, port: Port, drawable: xproto::Drawable, gc: xproto::Gcontext, vid_x: i16, vid_y: i16, vid_w: u16, vid_h: u16, drw_x: i16, drw_y: i16, drw_w: u16, drw_h: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let vid_x_bytes = vid_x.serialize(); - let vid_y_bytes = vid_y.serialize(); - let vid_w_bytes = vid_w.serialize(); - let vid_h_bytes = vid_h.serialize(); - let drw_x_bytes = drw_x.serialize(); - let drw_y_bytes = drw_y.serialize(); - let drw_w_bytes = drw_w.serialize(); - let drw_h_bytes = drw_h.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PUT_VIDEO_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - vid_x_bytes[0], - vid_x_bytes[1], - vid_y_bytes[0], - vid_y_bytes[1], - vid_w_bytes[0], - vid_w_bytes[1], - vid_h_bytes[0], - vid_h_bytes[1], - drw_x_bytes[0], - drw_x_bytes[1], - drw_y_bytes[0], - drw_y_bytes[1], - drw_w_bytes[0], - drw_w_bytes[1], - drw_h_bytes[0], - drw_h_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PutVideoRequest { + port, + drawable, + gc, + vid_x, + vid_y, + vid_w, + vid_h, + drw_x, + drw_y, + drw_w, + drw_h, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the PutStill request pub const PUT_STILL_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct PutStillRequest { + pub port: Port, + pub drawable: xproto::Drawable, + pub gc: xproto::Gcontext, + pub vid_x: i16, + pub vid_y: i16, + pub vid_w: u16, + pub vid_h: u16, + pub drw_x: i16, + pub drw_y: i16, + pub drw_w: u16, + pub drw_h: u16, +} +impl PutStillRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let vid_x_bytes = self.vid_x.serialize(); + let vid_y_bytes = self.vid_y.serialize(); + let vid_w_bytes = self.vid_w.serialize(); + let vid_h_bytes = self.vid_h.serialize(); + let drw_x_bytes = self.drw_x.serialize(); + let drw_y_bytes = self.drw_y.serialize(); + let drw_w_bytes = self.drw_w.serialize(); + let drw_h_bytes = self.drw_h.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PUT_STILL_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + vid_x_bytes[0], + vid_x_bytes[1], + vid_y_bytes[0], + vid_y_bytes[1], + vid_w_bytes[0], + vid_w_bytes[1], + vid_h_bytes[0], + vid_h_bytes[1], + drw_x_bytes[0], + drw_x_bytes[1], + drw_y_bytes[0], + drw_y_bytes[1], + drw_w_bytes[0], + drw_w_bytes[1], + drw_h_bytes[0], + drw_h_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn put_still(conn: &Conn, port: Port, drawable: xproto::Drawable, gc: xproto::Gcontext, vid_x: i16, vid_y: i16, vid_w: u16, vid_h: u16, drw_x: i16, drw_y: i16, drw_w: u16, drw_h: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let vid_x_bytes = vid_x.serialize(); - let vid_y_bytes = vid_y.serialize(); - let vid_w_bytes = vid_w.serialize(); - let vid_h_bytes = vid_h.serialize(); - let drw_x_bytes = drw_x.serialize(); - let drw_y_bytes = drw_y.serialize(); - let drw_w_bytes = drw_w.serialize(); - let drw_h_bytes = drw_h.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PUT_STILL_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - vid_x_bytes[0], - vid_x_bytes[1], - vid_y_bytes[0], - vid_y_bytes[1], - vid_w_bytes[0], - vid_w_bytes[1], - vid_h_bytes[0], - vid_h_bytes[1], - drw_x_bytes[0], - drw_x_bytes[1], - drw_y_bytes[0], - drw_y_bytes[1], - drw_w_bytes[0], - drw_w_bytes[1], - drw_h_bytes[0], - drw_h_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = PutStillRequest { + port, + drawable, + gc, + vid_x, + vid_y, + vid_w, + vid_h, + drw_x, + drw_y, + drw_w, + drw_h, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetVideo request pub const GET_VIDEO_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetVideoRequest { + pub port: Port, + pub drawable: xproto::Drawable, + pub gc: xproto::Gcontext, + pub vid_x: i16, + pub vid_y: i16, + pub vid_w: u16, + pub vid_h: u16, + pub drw_x: i16, + pub drw_y: i16, + pub drw_w: u16, + pub drw_h: u16, +} +impl GetVideoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let vid_x_bytes = self.vid_x.serialize(); + let vid_y_bytes = self.vid_y.serialize(); + let vid_w_bytes = self.vid_w.serialize(); + let vid_h_bytes = self.vid_h.serialize(); + let drw_x_bytes = self.drw_x.serialize(); + let drw_y_bytes = self.drw_y.serialize(); + let drw_w_bytes = self.drw_w.serialize(); + let drw_h_bytes = self.drw_h.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_VIDEO_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + vid_x_bytes[0], + vid_x_bytes[1], + vid_y_bytes[0], + vid_y_bytes[1], + vid_w_bytes[0], + vid_w_bytes[1], + vid_h_bytes[0], + vid_h_bytes[1], + drw_x_bytes[0], + drw_x_bytes[1], + drw_y_bytes[0], + drw_y_bytes[1], + drw_w_bytes[0], + drw_w_bytes[1], + drw_h_bytes[0], + drw_h_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_video(conn: &Conn, port: Port, drawable: xproto::Drawable, gc: xproto::Gcontext, vid_x: i16, vid_y: i16, vid_w: u16, vid_h: u16, drw_x: i16, drw_y: i16, drw_w: u16, drw_h: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let vid_x_bytes = vid_x.serialize(); - let vid_y_bytes = vid_y.serialize(); - let vid_w_bytes = vid_w.serialize(); - let vid_h_bytes = vid_h.serialize(); - let drw_x_bytes = drw_x.serialize(); - let drw_y_bytes = drw_y.serialize(); - let drw_w_bytes = drw_w.serialize(); - let drw_h_bytes = drw_h.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_VIDEO_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - vid_x_bytes[0], - vid_x_bytes[1], - vid_y_bytes[0], - vid_y_bytes[1], - vid_w_bytes[0], - vid_w_bytes[1], - vid_h_bytes[0], - vid_h_bytes[1], - drw_x_bytes[0], - drw_x_bytes[1], - drw_y_bytes[0], - drw_y_bytes[1], - drw_w_bytes[0], - drw_w_bytes[1], - drw_h_bytes[0], - drw_h_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetVideoRequest { + port, + drawable, + gc, + vid_x, + vid_y, + vid_w, + vid_h, + drw_x, + drw_y, + drw_w, + drw_h, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetStill request pub const GET_STILL_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetStillRequest { + pub port: Port, + pub drawable: xproto::Drawable, + pub gc: xproto::Gcontext, + pub vid_x: i16, + pub vid_y: i16, + pub vid_w: u16, + pub vid_h: u16, + pub drw_x: i16, + pub drw_y: i16, + pub drw_w: u16, + pub drw_h: u16, +} +impl GetStillRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let vid_x_bytes = self.vid_x.serialize(); + let vid_y_bytes = self.vid_y.serialize(); + let vid_w_bytes = self.vid_w.serialize(); + let vid_h_bytes = self.vid_h.serialize(); + let drw_x_bytes = self.drw_x.serialize(); + let drw_y_bytes = self.drw_y.serialize(); + let drw_w_bytes = self.drw_w.serialize(); + let drw_h_bytes = self.drw_h.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_STILL_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + vid_x_bytes[0], + vid_x_bytes[1], + vid_y_bytes[0], + vid_y_bytes[1], + vid_w_bytes[0], + vid_w_bytes[1], + vid_h_bytes[0], + vid_h_bytes[1], + drw_x_bytes[0], + drw_x_bytes[1], + drw_y_bytes[0], + drw_y_bytes[1], + drw_w_bytes[0], + drw_w_bytes[1], + drw_h_bytes[0], + drw_h_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_still(conn: &Conn, port: Port, drawable: xproto::Drawable, gc: xproto::Gcontext, vid_x: i16, vid_y: i16, vid_w: u16, vid_h: u16, drw_x: i16, drw_y: i16, drw_w: u16, drw_h: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let vid_x_bytes = vid_x.serialize(); - let vid_y_bytes = vid_y.serialize(); - let vid_w_bytes = vid_w.serialize(); - let vid_h_bytes = vid_h.serialize(); - let drw_x_bytes = drw_x.serialize(); - let drw_y_bytes = drw_y.serialize(); - let drw_w_bytes = drw_w.serialize(); - let drw_h_bytes = drw_h.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_STILL_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - vid_x_bytes[0], - vid_x_bytes[1], - vid_y_bytes[0], - vid_y_bytes[1], - vid_w_bytes[0], - vid_w_bytes[1], - vid_h_bytes[0], - vid_h_bytes[1], - drw_x_bytes[0], - drw_x_bytes[1], - drw_y_bytes[0], - drw_y_bytes[1], - drw_w_bytes[0], - drw_w_bytes[1], - drw_h_bytes[0], - drw_h_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetStillRequest { + port, + drawable, + gc, + vid_x, + vid_y, + vid_w, + vid_h, + drw_x, + drw_y, + drw_w, + drw_h, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the StopVideo request pub const STOP_VIDEO_REQUEST: u8 = 9; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct StopVideoRequest { + pub port: Port, + pub drawable: xproto::Drawable, +} +impl StopVideoRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let drawable_bytes = self.drawable.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + STOP_VIDEO_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn stop_video(conn: &Conn, port: Port, drawable: xproto::Drawable) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let drawable_bytes = drawable.serialize(); - let mut request0 = [ - extension_information.major_opcode, - STOP_VIDEO_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = StopVideoRequest { + port, + drawable, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SelectVideoNotify request pub const SELECT_VIDEO_NOTIFY_REQUEST: u8 = 10; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectVideoNotifyRequest { + pub drawable: xproto::Drawable, + pub onoff: bool, +} +impl SelectVideoNotifyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let drawable_bytes = self.drawable.serialize(); + let onoff_bytes = self.onoff.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_VIDEO_NOTIFY_REQUEST, + 0, + 0, + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + onoff_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn select_video_notify(conn: &Conn, drawable: xproto::Drawable, onoff: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let drawable_bytes = drawable.serialize(); - let onoff_bytes = onoff.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_VIDEO_NOTIFY_REQUEST, - 0, - 0, - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - onoff_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SelectVideoNotifyRequest { + drawable, + onoff, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the SelectPortNotify request pub const SELECT_PORT_NOTIFY_REQUEST: u8 = 11; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SelectPortNotifyRequest { + pub port: Port, + pub onoff: bool, +} +impl SelectPortNotifyRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let onoff_bytes = self.onoff.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SELECT_PORT_NOTIFY_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + onoff_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn select_port_notify(conn: &Conn, port: Port, onoff: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let onoff_bytes = onoff.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SELECT_PORT_NOTIFY_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - onoff_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SelectPortNotifyRequest { + port, + onoff, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the QueryBestSize request pub const QUERY_BEST_SIZE_REQUEST: u8 = 12; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryBestSizeRequest { + pub port: Port, + pub vid_w: u16, + pub vid_h: u16, + pub drw_w: u16, + pub drw_h: u16, + pub motion: bool, +} +impl QueryBestSizeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let vid_w_bytes = self.vid_w.serialize(); + let vid_h_bytes = self.vid_h.serialize(); + let drw_w_bytes = self.drw_w.serialize(); + let drw_h_bytes = self.drw_h.serialize(); + let motion_bytes = self.motion.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_BEST_SIZE_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + vid_w_bytes[0], + vid_w_bytes[1], + vid_h_bytes[0], + vid_h_bytes[1], + drw_w_bytes[0], + drw_w_bytes[1], + drw_h_bytes[0], + drw_h_bytes[1], + motion_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_best_size(conn: &Conn, port: Port, vid_w: u16, vid_h: u16, drw_w: u16, drw_h: u16, motion: bool) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let vid_w_bytes = vid_w.serialize(); - let vid_h_bytes = vid_h.serialize(); - let drw_w_bytes = drw_w.serialize(); - let drw_h_bytes = drw_h.serialize(); - let motion_bytes = motion.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_BEST_SIZE_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - vid_w_bytes[0], - vid_w_bytes[1], - vid_h_bytes[0], - vid_h_bytes[1], - drw_w_bytes[0], - drw_w_bytes[1], - drw_h_bytes[0], - drw_h_bytes[1], - motion_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryBestSizeRequest { + port, + vid_w, + vid_h, + drw_w, + drw_h, + motion, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -2238,71 +2568,113 @@ impl TryFrom<&[u8]> for QueryBestSizeReply { /// Opcode for the SetPortAttribute request pub const SET_PORT_ATTRIBUTE_REQUEST: u8 = 13; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SetPortAttributeRequest { + pub port: Port, + pub attribute: xproto::Atom, + pub value: i32, +} +impl SetPortAttributeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let attribute_bytes = self.attribute.serialize(); + let value_bytes = self.value.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SET_PORT_ATTRIBUTE_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + attribute_bytes[0], + attribute_bytes[1], + attribute_bytes[2], + attribute_bytes[3], + value_bytes[0], + value_bytes[1], + value_bytes[2], + value_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn set_port_attribute(conn: &Conn, port: Port, attribute: xproto::Atom, value: i32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let attribute_bytes = attribute.serialize(); - let value_bytes = value.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SET_PORT_ATTRIBUTE_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - attribute_bytes[0], - attribute_bytes[1], - attribute_bytes[2], - attribute_bytes[3], - value_bytes[0], - value_bytes[1], - value_bytes[2], - value_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = SetPortAttributeRequest { + port, + attribute, + value, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the GetPortAttribute request pub const GET_PORT_ATTRIBUTE_REQUEST: u8 = 14; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct GetPortAttributeRequest { + pub port: Port, + pub attribute: xproto::Atom, +} +impl GetPortAttributeRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let attribute_bytes = self.attribute.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + GET_PORT_ATTRIBUTE_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + attribute_bytes[0], + attribute_bytes[1], + attribute_bytes[2], + attribute_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn get_port_attribute(conn: &Conn, port: Port, attribute: xproto::Atom) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let attribute_bytes = attribute.serialize(); - let mut request0 = [ - extension_information.major_opcode, - GET_PORT_ATTRIBUTE_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - attribute_bytes[0], - attribute_bytes[1], - attribute_bytes[2], - attribute_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = GetPortAttributeRequest { + port, + attribute, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -2332,29 +2704,47 @@ impl TryFrom<&[u8]> for GetPortAttributeReply { /// Opcode for the QueryPortAttributes request pub const QUERY_PORT_ATTRIBUTES_REQUEST: u8 = 15; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryPortAttributesRequest { + pub port: Port, +} +impl QueryPortAttributesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_PORT_ATTRIBUTES_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_port_attributes(conn: &Conn, port: Port) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_PORT_ATTRIBUTES_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryPortAttributesRequest { + port, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2403,29 +2793,47 @@ impl QueryPortAttributesReply { /// Opcode for the ListImageFormats request pub const LIST_IMAGE_FORMATS_REQUEST: u8 = 16; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListImageFormatsRequest { + pub port: Port, +} +impl ListImageFormatsRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + LIST_IMAGE_FORMATS_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_image_formats(conn: &Conn, port: Port) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let mut request0 = [ - extension_information.major_opcode, - LIST_IMAGE_FORMATS_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListImageFormatsRequest { + port, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2472,40 +2880,64 @@ impl ListImageFormatsReply { /// Opcode for the QueryImageAttributes request pub const QUERY_IMAGE_ATTRIBUTES_REQUEST: u8 = 17; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryImageAttributesRequest { + pub port: Port, + pub id: u32, + pub width: u16, + pub height: u16, +} +impl QueryImageAttributesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let id_bytes = self.id.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_IMAGE_ATTRIBUTES_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_image_attributes(conn: &Conn, port: Port, id: u32, width: u16, height: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let id_bytes = id.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let mut request0 = [ - extension_information.major_opcode, - QUERY_IMAGE_ATTRIBUTES_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryImageAttributesRequest { + port, + id, + width, + height, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -2560,164 +2992,260 @@ impl QueryImageAttributesReply { /// Opcode for the PutImage request pub const PUT_IMAGE_REQUEST: u8 = 18; -pub fn put_image<'c, Conn>(conn: &'c Conn, port: Port, drawable: xproto::Drawable, gc: xproto::Gcontext, id: u32, src_x: i16, src_y: i16, src_w: u16, src_h: u16, drw_x: i16, drw_y: i16, drw_w: u16, drw_h: u16, width: u16, height: u16, data: &[u8]) -> Result, ConnectionError> +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PutImageRequest<'input> { + pub port: Port, + pub drawable: xproto::Drawable, + pub gc: xproto::Gcontext, + pub id: u32, + pub src_x: i16, + pub src_y: i16, + pub src_w: u16, + pub src_h: u16, + pub drw_x: i16, + pub drw_y: i16, + pub drw_w: u16, + pub drw_h: u16, + pub width: u16, + pub height: u16, + pub data: &'input [u8], +} +impl<'input> PutImageRequest<'input> { + /// Serialize this request into bytes for the provided connection + fn serialize(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let id_bytes = self.id.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let src_w_bytes = self.src_w.serialize(); + let src_h_bytes = self.src_h.serialize(); + let drw_x_bytes = self.drw_x.serialize(); + let drw_y_bytes = self.drw_y.serialize(); + let drw_w_bytes = self.drw_w.serialize(); + let drw_h_bytes = self.drw_h.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + PUT_IMAGE_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + src_w_bytes[0], + src_w_bytes[1], + src_h_bytes[0], + src_h_bytes[1], + drw_x_bytes[0], + drw_x_bytes[1], + drw_y_bytes[0], + drw_y_bytes[1], + drw_w_bytes[0], + drw_w_bytes[1], + drw_h_bytes[0], + drw_h_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + let length_so_far = length_so_far + (&self.data[..]).len(); + let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; + let length_so_far = length_so_far + padding0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into(), (&self.data[..]).into(), padding0.into()], vec![])) + } +} +pub fn put_image<'c, 'input, Conn>(conn: &'c Conn, port: Port, drawable: xproto::Drawable, gc: xproto::Gcontext, id: u32, src_x: i16, src_y: i16, src_w: u16, src_h: u16, drw_x: i16, drw_y: i16, drw_w: u16, drw_h: u16, width: u16, height: u16, data: &'input [u8]) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let id_bytes = id.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let src_w_bytes = src_w.serialize(); - let src_h_bytes = src_h.serialize(); - let drw_x_bytes = drw_x.serialize(); - let drw_y_bytes = drw_y.serialize(); - let drw_w_bytes = drw_w.serialize(); - let drw_h_bytes = drw_h.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let mut request0 = [ - extension_information.major_opcode, - PUT_IMAGE_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - src_w_bytes[0], - src_w_bytes[1], - src_h_bytes[0], - src_h_bytes[1], - drw_x_bytes[0], - drw_x_bytes[1], - drw_y_bytes[0], - drw_y_bytes[1], - drw_w_bytes[0], - drw_w_bytes[1], - drw_h_bytes[0], - drw_h_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - let length_so_far = length_so_far + data.len(); - let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4]; - let length_so_far = length_so_far + padding0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0), IoSlice::new(data), IoSlice::new(&padding0)], vec![])?) + let request0 = PutImageRequest { + port, + drawable, + gc, + id, + src_x, + src_y, + src_w, + src_h, + drw_x, + drw_y, + drw_w, + drw_h, + width, + height, + data, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ShmPutImage request pub const SHM_PUT_IMAGE_REQUEST: u8 = 19; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ShmPutImageRequest { + pub port: Port, + pub drawable: xproto::Drawable, + pub gc: xproto::Gcontext, + pub shmseg: shm::Seg, + pub id: u32, + pub offset: u32, + pub src_x: i16, + pub src_y: i16, + pub src_w: u16, + pub src_h: u16, + pub drw_x: i16, + pub drw_y: i16, + pub drw_w: u16, + pub drw_h: u16, + pub width: u16, + pub height: u16, + pub send_event: u8, +} +impl ShmPutImageRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_bytes = self.port.serialize(); + let drawable_bytes = self.drawable.serialize(); + let gc_bytes = self.gc.serialize(); + let shmseg_bytes = self.shmseg.serialize(); + let id_bytes = self.id.serialize(); + let offset_bytes = self.offset.serialize(); + let src_x_bytes = self.src_x.serialize(); + let src_y_bytes = self.src_y.serialize(); + let src_w_bytes = self.src_w.serialize(); + let src_h_bytes = self.src_h.serialize(); + let drw_x_bytes = self.drw_x.serialize(); + let drw_y_bytes = self.drw_y.serialize(); + let drw_w_bytes = self.drw_w.serialize(); + let drw_h_bytes = self.drw_h.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let send_event_bytes = self.send_event.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + SHM_PUT_IMAGE_REQUEST, + 0, + 0, + port_bytes[0], + port_bytes[1], + port_bytes[2], + port_bytes[3], + drawable_bytes[0], + drawable_bytes[1], + drawable_bytes[2], + drawable_bytes[3], + gc_bytes[0], + gc_bytes[1], + gc_bytes[2], + gc_bytes[3], + shmseg_bytes[0], + shmseg_bytes[1], + shmseg_bytes[2], + shmseg_bytes[3], + id_bytes[0], + id_bytes[1], + id_bytes[2], + id_bytes[3], + offset_bytes[0], + offset_bytes[1], + offset_bytes[2], + offset_bytes[3], + src_x_bytes[0], + src_x_bytes[1], + src_y_bytes[0], + src_y_bytes[1], + src_w_bytes[0], + src_w_bytes[1], + src_h_bytes[0], + src_h_bytes[1], + drw_x_bytes[0], + drw_x_bytes[1], + drw_y_bytes[0], + drw_y_bytes[1], + drw_w_bytes[0], + drw_w_bytes[1], + drw_h_bytes[0], + drw_h_bytes[1], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + send_event_bytes[0], + 0, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn shm_put_image(conn: &Conn, port: Port, drawable: xproto::Drawable, gc: xproto::Gcontext, shmseg: shm::Seg, id: u32, offset: u32, src_x: i16, src_y: i16, src_w: u16, src_h: u16, drw_x: i16, drw_y: i16, drw_w: u16, drw_h: u16, width: u16, height: u16, send_event: u8) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_bytes = port.serialize(); - let drawable_bytes = drawable.serialize(); - let gc_bytes = gc.serialize(); - let shmseg_bytes = shmseg.serialize(); - let id_bytes = id.serialize(); - let offset_bytes = offset.serialize(); - let src_x_bytes = src_x.serialize(); - let src_y_bytes = src_y.serialize(); - let src_w_bytes = src_w.serialize(); - let src_h_bytes = src_h.serialize(); - let drw_x_bytes = drw_x.serialize(); - let drw_y_bytes = drw_y.serialize(); - let drw_w_bytes = drw_w.serialize(); - let drw_h_bytes = drw_h.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let send_event_bytes = send_event.serialize(); - let mut request0 = [ - extension_information.major_opcode, - SHM_PUT_IMAGE_REQUEST, - 0, - 0, - port_bytes[0], - port_bytes[1], - port_bytes[2], - port_bytes[3], - drawable_bytes[0], - drawable_bytes[1], - drawable_bytes[2], - drawable_bytes[3], - gc_bytes[0], - gc_bytes[1], - gc_bytes[2], - gc_bytes[3], - shmseg_bytes[0], - shmseg_bytes[1], - shmseg_bytes[2], - shmseg_bytes[3], - id_bytes[0], - id_bytes[1], - id_bytes[2], - id_bytes[3], - offset_bytes[0], - offset_bytes[1], - offset_bytes[2], - offset_bytes[3], - src_x_bytes[0], - src_x_bytes[1], - src_y_bytes[0], - src_y_bytes[1], - src_w_bytes[0], - src_w_bytes[1], - src_h_bytes[0], - src_h_bytes[1], - drw_x_bytes[0], - drw_x_bytes[1], - drw_y_bytes[0], - drw_y_bytes[1], - drw_w_bytes[0], - drw_w_bytes[1], - drw_h_bytes[0], - drw_h_bytes[1], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - send_event_bytes[0], - 0, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ShmPutImageRequest { + port, + drawable, + gc, + shmseg, + id, + offset, + src_x, + src_y, + src_w, + src_h, + drw_x, + drw_y, + drw_w, + drw_h, + width, + height, + send_event, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Extension trait defining the requests of this extension. @@ -2798,7 +3326,7 @@ pub trait ConnectionExt: RequestConnection { { query_image_attributes(self, port, id, width, height) } - fn xv_put_image<'c>(&'c self, port: Port, drawable: xproto::Drawable, gc: xproto::Gcontext, id: u32, src_x: i16, src_y: i16, src_w: u16, src_h: u16, drw_x: i16, drw_y: i16, drw_w: u16, drw_h: u16, width: u16, height: u16, data: &[u8]) -> Result, ConnectionError> + fn xv_put_image<'c, 'input>(&'c self, port: Port, drawable: xproto::Drawable, gc: xproto::Gcontext, id: u32, src_x: i16, src_y: i16, src_w: u16, src_h: u16, drw_x: i16, drw_y: i16, drw_w: u16, drw_h: u16, width: u16, height: u16, data: &'input [u8]) -> Result, ConnectionError> { put_image(self, port, drawable, gc, id, src_x, src_y, src_w, src_h, drw_x, drw_y, drw_w, drw_h, width, height, data) } diff --git a/src/protocol/xvmc.rs b/src/protocol/xvmc.rs index 7ccfafa7..671793c7 100644 --- a/src/protocol/xvmc.rs +++ b/src/protocol/xvmc.rs @@ -16,7 +16,7 @@ use std::io::IoSlice; use crate::utils::RawFdContainer; #[allow(unused_imports)] use crate::x11_utils::{Serialize, TryParse}; -use crate::connection::RequestConnection; +use crate::connection::{BufWithFds, PiecewiseBuf, RequestConnection}; #[allow(unused_imports)] use crate::cookie::{Cookie, CookieWithFds, VoidCookie}; use crate::errors::{ConnectionError, ParseError}; @@ -127,24 +127,38 @@ impl Serialize for SurfaceInfo { /// Opcode for the QueryVersion request pub const QUERY_VERSION_REQUEST: u8 = 0; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct QueryVersionRequest; +impl QueryVersionRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let mut request0 = vec![ + extension_information.major_opcode, + QUERY_VERSION_REQUEST, + 0, + 0, + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn query_version(conn: &Conn) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let mut request0 = [ - extension_information.major_opcode, - QUERY_VERSION_REQUEST, - 0, - 0, - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = QueryVersionRequest; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -176,29 +190,47 @@ impl TryFrom<&[u8]> for QueryVersionReply { /// Opcode for the ListSurfaceTypes request pub const LIST_SURFACE_TYPES_REQUEST: u8 = 1; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListSurfaceTypesRequest { + pub port_id: xv::Port, +} +impl ListSurfaceTypesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_id_bytes = self.port_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + LIST_SURFACE_TYPES_REQUEST, + 0, + 0, + port_id_bytes[0], + port_id_bytes[1], + port_id_bytes[2], + port_id_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_surface_types(conn: &Conn, port_id: xv::Port) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_id_bytes = port_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - LIST_SURFACE_TYPES_REQUEST, - 0, - 0, - port_id_bytes[0], - port_id_bytes[1], - port_id_bytes[2], - port_id_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListSurfaceTypesRequest { + port_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -245,50 +277,78 @@ impl ListSurfaceTypesReply { /// Opcode for the CreateContext request pub const CREATE_CONTEXT_REQUEST: u8 = 2; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateContextRequest { + pub context_id: Context, + pub port_id: xv::Port, + pub surface_id: Surface, + pub width: u16, + pub height: u16, + pub flags: u32, +} +impl CreateContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_id_bytes = self.context_id.serialize(); + let port_id_bytes = self.port_id.serialize(); + let surface_id_bytes = self.surface_id.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let flags_bytes = self.flags.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_CONTEXT_REQUEST, + 0, + 0, + context_id_bytes[0], + context_id_bytes[1], + context_id_bytes[2], + context_id_bytes[3], + port_id_bytes[0], + port_id_bytes[1], + port_id_bytes[2], + port_id_bytes[3], + surface_id_bytes[0], + surface_id_bytes[1], + surface_id_bytes[2], + surface_id_bytes[3], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + flags_bytes[0], + flags_bytes[1], + flags_bytes[2], + flags_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_context(conn: &Conn, context_id: Context, port_id: xv::Port, surface_id: Surface, width: u16, height: u16, flags: u32) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_id_bytes = context_id.serialize(); - let port_id_bytes = port_id.serialize(); - let surface_id_bytes = surface_id.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let flags_bytes = flags.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_CONTEXT_REQUEST, - 0, - 0, - context_id_bytes[0], - context_id_bytes[1], - context_id_bytes[2], - context_id_bytes[3], - port_id_bytes[0], - port_id_bytes[1], - port_id_bytes[2], - port_id_bytes[3], - surface_id_bytes[0], - surface_id_bytes[1], - surface_id_bytes[2], - surface_id_bytes[3], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - flags_bytes[0], - flags_bytes[1], - flags_bytes[2], - flags_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateContextRequest { + context_id, + port_id, + surface_id, + width, + height, + flags, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -339,61 +399,99 @@ impl CreateContextReply { /// Opcode for the DestroyContext request pub const DESTROY_CONTEXT_REQUEST: u8 = 3; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroyContextRequest { + pub context_id: Context, +} +impl DestroyContextRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let context_id_bytes = self.context_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_CONTEXT_REQUEST, + 0, + 0, + context_id_bytes[0], + context_id_bytes[1], + context_id_bytes[2], + context_id_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_context(conn: &Conn, context_id: Context) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let context_id_bytes = context_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_CONTEXT_REQUEST, - 0, - 0, - context_id_bytes[0], - context_id_bytes[1], - context_id_bytes[2], - context_id_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroyContextRequest { + context_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateSurface request pub const CREATE_SURFACE_REQUEST: u8 = 4; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateSurfaceRequest { + pub surface_id: Surface, + pub context_id: Context, +} +impl CreateSurfaceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let surface_id_bytes = self.surface_id.serialize(); + let context_id_bytes = self.context_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_SURFACE_REQUEST, + 0, + 0, + surface_id_bytes[0], + surface_id_bytes[1], + surface_id_bytes[2], + surface_id_bytes[3], + context_id_bytes[0], + context_id_bytes[1], + context_id_bytes[2], + context_id_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_surface(conn: &Conn, surface_id: Surface, context_id: Context) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let surface_id_bytes = surface_id.serialize(); - let context_id_bytes = context_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_SURFACE_REQUEST, - 0, - 0, - surface_id_bytes[0], - surface_id_bytes[1], - surface_id_bytes[2], - surface_id_bytes[3], - context_id_bytes[0], - context_id_bytes[1], - context_id_bytes[2], - context_id_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateSurfaceRequest { + surface_id, + context_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -438,72 +536,116 @@ impl CreateSurfaceReply { /// Opcode for the DestroySurface request pub const DESTROY_SURFACE_REQUEST: u8 = 5; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroySurfaceRequest { + pub surface_id: Surface, +} +impl DestroySurfaceRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let surface_id_bytes = self.surface_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_SURFACE_REQUEST, + 0, + 0, + surface_id_bytes[0], + surface_id_bytes[1], + surface_id_bytes[2], + surface_id_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_surface(conn: &Conn, surface_id: Surface) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let surface_id_bytes = surface_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_SURFACE_REQUEST, - 0, - 0, - surface_id_bytes[0], - surface_id_bytes[1], - surface_id_bytes[2], - surface_id_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroySurfaceRequest { + surface_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the CreateSubpicture request pub const CREATE_SUBPICTURE_REQUEST: u8 = 6; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CreateSubpictureRequest { + pub subpicture_id: Subpicture, + pub context: Context, + pub xvimage_id: u32, + pub width: u16, + pub height: u16, +} +impl CreateSubpictureRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let subpicture_id_bytes = self.subpicture_id.serialize(); + let context_bytes = self.context.serialize(); + let xvimage_id_bytes = self.xvimage_id.serialize(); + let width_bytes = self.width.serialize(); + let height_bytes = self.height.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + CREATE_SUBPICTURE_REQUEST, + 0, + 0, + subpicture_id_bytes[0], + subpicture_id_bytes[1], + subpicture_id_bytes[2], + subpicture_id_bytes[3], + context_bytes[0], + context_bytes[1], + context_bytes[2], + context_bytes[3], + xvimage_id_bytes[0], + xvimage_id_bytes[1], + xvimage_id_bytes[2], + xvimage_id_bytes[3], + width_bytes[0], + width_bytes[1], + height_bytes[0], + height_bytes[1], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn create_subpicture(conn: &Conn, subpicture_id: Subpicture, context: Context, xvimage_id: u32, width: u16, height: u16) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let subpicture_id_bytes = subpicture_id.serialize(); - let context_bytes = context.serialize(); - let xvimage_id_bytes = xvimage_id.serialize(); - let width_bytes = width.serialize(); - let height_bytes = height.serialize(); - let mut request0 = [ - extension_information.major_opcode, - CREATE_SUBPICTURE_REQUEST, - 0, - 0, - subpicture_id_bytes[0], - subpicture_id_bytes[1], - subpicture_id_bytes[2], - subpicture_id_bytes[3], - context_bytes[0], - context_bytes[1], - context_bytes[2], - context_bytes[3], - xvimage_id_bytes[0], - xvimage_id_bytes[1], - xvimage_id_bytes[2], - xvimage_id_bytes[3], - width_bytes[0], - width_bytes[1], - height_bytes[0], - height_bytes[1], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = CreateSubpictureRequest { + subpicture_id, + context, + xvimage_id, + width, + height, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)] @@ -559,61 +701,99 @@ impl CreateSubpictureReply { /// Opcode for the DestroySubpicture request pub const DESTROY_SUBPICTURE_REQUEST: u8 = 7; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct DestroySubpictureRequest { + pub subpicture_id: Subpicture, +} +impl DestroySubpictureRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let subpicture_id_bytes = self.subpicture_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + DESTROY_SUBPICTURE_REQUEST, + 0, + 0, + subpicture_id_bytes[0], + subpicture_id_bytes[1], + subpicture_id_bytes[2], + subpicture_id_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn destroy_subpicture(conn: &Conn, subpicture_id: Subpicture) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let subpicture_id_bytes = subpicture_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - DESTROY_SUBPICTURE_REQUEST, - 0, - 0, - subpicture_id_bytes[0], - subpicture_id_bytes[1], - subpicture_id_bytes[2], - subpicture_id_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_without_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = DestroySubpictureRequest { + subpicture_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_without_reply(&slices, fds)?) } /// Opcode for the ListSubpictureTypes request pub const LIST_SUBPICTURE_TYPES_REQUEST: u8 = 8; +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ListSubpictureTypesRequest { + pub port_id: xv::Port, + pub surface_id: Surface, +} +impl ListSubpictureTypesRequest { + /// Serialize this request into bytes for the provided connection + fn serialize<'input, Conn>(self, conn: &Conn) -> Result>, ConnectionError> + where + Conn: RequestConnection + ?Sized, + { + let extension_information = conn.extension_information(X11_EXTENSION_NAME)? + .ok_or(ConnectionError::UnsupportedExtension)?; + let length_so_far = 0; + let port_id_bytes = self.port_id.serialize(); + let surface_id_bytes = self.surface_id.serialize(); + let mut request0 = vec![ + extension_information.major_opcode, + LIST_SUBPICTURE_TYPES_REQUEST, + 0, + 0, + port_id_bytes[0], + port_id_bytes[1], + port_id_bytes[2], + port_id_bytes[3], + surface_id_bytes[0], + surface_id_bytes[1], + surface_id_bytes[2], + surface_id_bytes[3], + ]; + let length_so_far = length_so_far + request0.len(); + assert_eq!(length_so_far % 4, 0); + let length = u16::try_from(length_so_far / 4).unwrap_or(0); + request0[2..4].copy_from_slice(&length.to_ne_bytes()); + Ok((vec![request0.into()], vec![])) + } +} pub fn list_subpicture_types(conn: &Conn, port_id: xv::Port, surface_id: Surface) -> Result, ConnectionError> where Conn: RequestConnection + ?Sized, { - let extension_information = conn.extension_information(X11_EXTENSION_NAME)? - .ok_or(ConnectionError::UnsupportedExtension)?; - let length_so_far = 0; - let port_id_bytes = port_id.serialize(); - let surface_id_bytes = surface_id.serialize(); - let mut request0 = [ - extension_information.major_opcode, - LIST_SUBPICTURE_TYPES_REQUEST, - 0, - 0, - port_id_bytes[0], - port_id_bytes[1], - port_id_bytes[2], - port_id_bytes[3], - surface_id_bytes[0], - surface_id_bytes[1], - surface_id_bytes[2], - surface_id_bytes[3], - ]; - let length_so_far = length_so_far + request0.len(); - assert_eq!(length_so_far % 4, 0); - let length = u16::try_from(length_so_far / 4).unwrap_or(0); - request0[2..4].copy_from_slice(&length.to_ne_bytes()); - Ok(conn.send_request_with_reply(&[IoSlice::new(&request0)], vec![])?) + let request0 = ListSubpictureTypesRequest { + port_id, + surface_id, + }; + let (bytes, fds) = request0.serialize(conn)?; + let slices = bytes.iter().map(|b| IoSlice::new(&*b)).collect::>(); + Ok(conn.send_request_with_reply(&slices, fds)?) } #[derive(Debug, Clone, PartialEq, Eq)]