Generate wrappers

examples/shared_memory.rs

@@ -11,8 +11,7 @@ use libc::{mmap, MAP_FAILED, MAP_SHARED, PROT_READ, PROT_WRITE};
 use x11rb::connection::Connection;
 use x11rb::errors::{ConnectionError, ReplyError, ReplyOrIdError};
 use x11rb::protocol::shm::{self, ConnectionExt as _};
-use x11rb::protocol::xproto::{self, ImageFormat};
-use x11rb::wrapper::PixmapWrapper;
+use x11rb::protocol::xproto::{self, ImageFormat, PixmapWrapper};
 
 const TEMP_FILE_CONTENT: [u8; 8] = [0x00, 0x01, 0x02, 0x03, 0xff, 0xfe, 0xfd, 0xfc];
 

examples/xeyes.rs

@@ -7,7 +7,7 @@ use x11rb::errors::{ConnectionError, ReplyOrIdError};
 use x11rb::protocol::shape::{self, ConnectionExt as _};
 use x11rb::protocol::xproto::*;
 use x11rb::protocol::Event;
-use x11rb::wrapper::{ConnectionExt as _, GcontextWrapper, PixmapWrapper};
+use x11rb::wrapper::ConnectionExt as _;
 use x11rb::COPY_DEPTH_FROM_PARENT;
 
 const PUPIL_SIZE: i16 = 50;
@@ -170,12 +170,18 @@ fn shape_window<C: Connection>(
         width: window_size.0,
         height: window_size.1,
     };
-    conn.poly_fill_rectangle(pixmap.pixmap(), gc.gc(), &[rect])?;
+    conn.poly_fill_rectangle(pixmap.pixmap(), gc.gcontext(), &[rect])?;
 
     // Draw the eyes as "not transparent"
     let values = ChangeGCAux::new().foreground(1);
-    conn.change_gc(gc.gc(), &values)?;
-    draw_eyes(conn, pixmap.pixmap(), gc.gc(), gc.gc(), window_size)?;
+    conn.change_gc(gc.gcontext(), &values)?;
+    draw_eyes(
+        conn,
+        pixmap.pixmap(),
+        gc.gcontext(),
+        gc.gcontext(),
+        window_size,
+    )?;
 
     // Set the shape of the window
     conn.shape_mask(shape::SO::SET, shape::SK::BOUNDING, win_id, 0, 0, &pixmap)?;
@@ -344,18 +350,18 @@ fn main() {
             draw_eyes(
                 conn,
                 pixmap.pixmap(),
-                black_gc.gc(),
-                white_gc.gc(),
+                black_gc.gcontext(),
+                white_gc.gcontext(),
                 window_size,
             )
             .unwrap();
-            draw_pupils(conn, pixmap.pixmap(), black_gc.gc(), pos).unwrap();
+            draw_pupils(conn, pixmap.pixmap(), black_gc.gcontext(), pos).unwrap();
 
             // Copy drawing from pixmap to window
             conn.copy_area(
                 pixmap.pixmap(),
                 win_id,
-                white_gc.gc(),
+                white_gc.gcontext(),
                 0,
                 0,
                 0,

generator/src/generator/mod.rs

@@ -51,7 +51,11 @@ pub(crate) fn generate(module: &xcbgen::defs::Module) -> HashMap<PathBuf, String
     let mut enum_cases = HashMap::new();
     for ns in module.sorted_namespaces() {
         let mut ns_out = Output::new();
-        namespace::generate(&ns, &caches, &mut ns_out, &mut enum_cases);
+        let wrapper_info = match ns.ext_info {
+            None => &XPROTO_RESOURCES[..],
+            Some(_) => &[],
+        };
+        namespace::generate(&ns, &caches, &mut ns_out, &mut enum_cases, wrapper_info);
         out_map.insert(
             PathBuf::from(format!("{}.rs", ns.header)),
             ns_out.into_data(),
@@ -211,3 +215,86 @@ pub(crate) fn get_ns_name_prefix(ns: &xcbgen::defs::Namespace) -> String {
         String::new()
     }
 }
+
+struct CreateInfo<'a> {
+    request_name: &'a str,
+    created_argument: &'a str,
+}
+
+struct ResourceInfo<'a> {
+    resource_name: &'a str,
+    create_requests: [Option<CreateInfo<'a>>; 2],
+    free_request: &'a str,
+}
+
+const XPROTO_RESOURCES: [ResourceInfo<'static>; 6] = [
+    ResourceInfo {
+        resource_name: "Pixmap",
+        create_requests: [
+            Some(CreateInfo {
+                request_name: "CreatePixmap",
+                created_argument: "pid",
+            }),
+            None,
+        ],
+        free_request: "FreePixmap",
+    },
+    ResourceInfo {
+        resource_name: "Window",
+        create_requests: [
+            Some(CreateInfo {
+                request_name: "CreateWindow",
+                created_argument: "wid",
+            }),
+            None,
+        ],
+        free_request: "DestroyWindow",
+    },
+    ResourceInfo {
+        resource_name: "Font",
+        create_requests: [
+            Some(CreateInfo {
+                request_name: "OpenFont",
+                created_argument: "fid",
+            }),
+            None,
+        ],
+        free_request: "CloseFont",
+    },
+    ResourceInfo {
+        resource_name: "Gcontext",
+        create_requests: [
+            Some(CreateInfo {
+                request_name: "CreateGC",
+                created_argument: "cid",
+            }),
+            None,
+        ],
+        free_request: "FreeGC",
+    },
+    ResourceInfo {
+        resource_name: "Colormap",
+        create_requests: [
+            Some(CreateInfo {
+                request_name: "CreateColormap",
+                created_argument: "mid",
+            }),
+            None,
+        ],
+        free_request: "FreeColormap",
+    },
+    ResourceInfo {
+        resource_name: "Cursor",
+        create_requests: [
+            Some(CreateInfo {
+                request_name: "CreateCursor",
+                created_argument: "cid",
+            }),
+            Some(CreateInfo {
+                request_name: "CreateGlyphCursor",
+                created_argument: "cid",
+            }),
+        ],
+        free_request: "FreeCursor",
+    },
+];

generator/src/generator/namespace/header.rs

@@ -47,6 +47,8 @@ pub(super) fn write_header(out: &mut Output, ns: &xcbdefs::Namespace) {
         "use crate::connection::{{BufWithFds, PiecewiseBuf, RequestConnection}};"
     );
     outln!(out, "#[allow(unused_imports)]");
+    outln!(out, "use crate::connection::Connection as X11Connection;");
+    outln!(out, "#[allow(unused_imports)]");
     outln!(
         out,
         "use crate::cookie::{{Cookie, CookieWithFds, VoidCookie}};"
@@ -58,6 +60,8 @@ pub(super) fn write_header(out: &mut Output, ns: &xcbdefs::Namespace) {
         outln!(out, "use crate::cookie::RecordEnableContextCookie;");
     }
     outln!(out, "use crate::errors::{{ConnectionError, ParseError}};");
+    outln!(out, "#[allow(unused_imports)]");
+    outln!(out, "use crate::errors::ReplyOrIdError;");
 
     let mut imports = ns
         .imports

generator/src/generator/namespace/mod.rs

@@ -19,6 +19,7 @@ mod header;
 pub(super) mod helpers;
 mod parse;
 mod request;
+mod resource_wrapper;
 mod serialize;
 mod struct_type;
 mod switch;
@@ -38,8 +39,9 @@ pub(super) fn generate(
     caches: &RefCell<Caches>,
     out: &mut Output,
     enum_cases: &mut EnumCases,
+    resource_info: &[super::ResourceInfo<'_>],
 ) {
-    NamespaceGenerator::new(ns, caches).generate(out, enum_cases);
+    NamespaceGenerator::new(ns, caches).generate(out, enum_cases, resource_info);
 }
 
 struct NamespaceGenerator<'ns, 'c> {
@@ -65,7 +67,12 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> {
         }
     }
 
-    fn generate(&self, out: &mut Output, enum_cases: &mut EnumCases) {
+    fn generate(
+        &self,
+        out: &mut Output,
+        enum_cases: &mut EnumCases,
+        resource_info: &[super::ResourceInfo<'_>],
+    ) {
         super::write_code_header(out);
         header::write_header(out, &self.ns);
 
@@ -129,6 +136,10 @@ impl<'ns, 'c> NamespaceGenerator<'ns, 'c> {
             out,
             "impl<C: RequestConnection + ?Sized> ConnectionExt for C {{}}",
         );
+
+        for info in resource_info {
+            resource_wrapper::generate(self, out, info);
+        }
     }
 
     fn generate_event_full_def(&self, event_full_def: &xcbdefs::EventFullDef, out: &mut Output) {