From 1a34cf63153d09d8f3eccb358a8270333618dbfe Mon Sep 17 00:00:00 2001
From: Bill Avery <wravery@gmail.com>
Date: Mon, 30 Dec 2024 08:23:07 -0800
Subject: [PATCH] fix: add missing sys bindnigs

---
 cef/src/bindings.rs | 4063 +++++++++++++++++++++++++++++++++++--------
 sys/src/bindings.rs | 1034 +++++++++--
 sys/wrapper.h       |   18 +-
 3 files changed, 4242 insertions(+), 873 deletions(-)

diff --git a/cef/src/bindings.rs b/cef/src/bindings.rs
index e26cef2..18cca21 100644
--- a/cef/src/bindings.rs
+++ b/cef/src/bindings.rs
@@ -5209,7 +5209,7 @@ impl Default for Image {
     }
 }
 pub trait ImplReadHandler: Sized {
-    fn read(&self, ptr: &mut ::std::os::raw::c_void, size: usize, n: usize) -> usize {
+    fn read(&self, ptr: *mut ::std::os::raw::c_void, size: usize, n: usize) -> usize {
         unsafe { std::mem::zeroed() }
     }
     fn seek(&self, offset: i64, whence: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
@@ -5247,8 +5247,6 @@ mod impl_cef_read_handler_t {
     ) -> usize {
         let (arg_self_, arg_ptr, arg_size, arg_n) = (self_, ptr, size, n);
         let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let mut arg_ptr = WrapParamRef::<::std::os::raw::c_void>::from(arg_ptr);
-        let arg_ptr = arg_ptr.as_mut();
         let arg_size = arg_size.as_raw();
         let arg_n = arg_n.as_raw();
         arg_self_.interface.read(arg_ptr, arg_size, arg_n).into()
@@ -5288,7 +5286,7 @@ mod impl_cef_read_handler_t {
 #[derive(Clone)]
 pub struct ReadHandler(RefGuard<_cef_read_handler_t>);
 impl ImplReadHandler for ReadHandler {
-    fn read(&self, ptr: &mut ::std::os::raw::c_void, size: usize, n: usize) -> usize {
+    fn read(&self, ptr: *mut ::std::os::raw::c_void, size: usize, n: usize) -> usize {
         unsafe {
             self.0
                 .read
@@ -5392,7 +5390,7 @@ impl Default for ReadHandler {
     }
 }
 pub trait ImplStreamReader: Sized {
-    fn read(&self, ptr: &mut ::std::os::raw::c_void, size: usize, n: usize) -> usize {
+    fn read(&self, ptr: *mut ::std::os::raw::c_void, size: usize, n: usize) -> usize {
         unsafe { std::mem::zeroed() }
     }
     fn seek(&self, offset: i64, whence: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
@@ -5430,8 +5428,6 @@ mod impl_cef_stream_reader_t {
     ) -> usize {
         let (arg_self_, arg_ptr, arg_size, arg_n) = (self_, ptr, size, n);
         let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let mut arg_ptr = WrapParamRef::<::std::os::raw::c_void>::from(arg_ptr);
-        let arg_ptr = arg_ptr.as_mut();
         let arg_size = arg_size.as_raw();
         let arg_n = arg_n.as_raw();
         arg_self_.interface.read(arg_ptr, arg_size, arg_n).into()
@@ -5471,7 +5467,7 @@ mod impl_cef_stream_reader_t {
 #[derive(Clone)]
 pub struct StreamReader(RefGuard<_cef_stream_reader_t>);
 impl ImplStreamReader for StreamReader {
-    fn read(&self, ptr: &mut ::std::os::raw::c_void, size: usize, n: usize) -> usize {
+    fn read(&self, ptr: *mut ::std::os::raw::c_void, size: usize, n: usize) -> usize {
         unsafe {
             self.0
                 .read
@@ -5575,7 +5571,7 @@ impl Default for StreamReader {
     }
 }
 pub trait ImplWriteHandler: Sized {
-    fn write(&self, ptr: &[::std::os::raw::c_void], size: usize, n: usize) -> usize {
+    fn write(&self, ptr: *const ::std::os::raw::c_void, size: usize, n: usize) -> usize {
         unsafe { std::mem::zeroed() }
     }
     fn seek(&self, offset: i64, whence: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
@@ -5613,8 +5609,6 @@ mod impl_cef_write_handler_t {
     ) -> usize {
         let (arg_self_, arg_ptr, arg_size, arg_n) = (self_, ptr, size, n);
         let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let arg_ptr = WrapParamRef::<::std::os::raw::c_void>::from(arg_ptr);
-        let arg_ptr = arg_ptr.as_ref();
         let arg_size = arg_size.as_raw();
         let arg_n = arg_n.as_raw();
         arg_self_.interface.write(arg_ptr, arg_size, arg_n).into()
@@ -5654,7 +5648,7 @@ mod impl_cef_write_handler_t {
 #[derive(Clone)]
 pub struct WriteHandler(RefGuard<_cef_write_handler_t>);
 impl ImplWriteHandler for WriteHandler {
-    fn write(&self, ptr: &[::std::os::raw::c_void], size: usize, n: usize) -> usize {
+    fn write(&self, ptr: *const ::std::os::raw::c_void, size: usize, n: usize) -> usize {
         unsafe {
             self.0
                 .write
@@ -5758,7 +5752,7 @@ impl Default for WriteHandler {
     }
 }
 pub trait ImplStreamWriter: Sized {
-    fn write(&self, ptr: &[::std::os::raw::c_void], size: usize, n: usize) -> usize {
+    fn write(&self, ptr: *const ::std::os::raw::c_void, size: usize, n: usize) -> usize {
         unsafe { std::mem::zeroed() }
     }
     fn seek(&self, offset: i64, whence: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
@@ -5796,8 +5790,6 @@ mod impl_cef_stream_writer_t {
     ) -> usize {
         let (arg_self_, arg_ptr, arg_size, arg_n) = (self_, ptr, size, n);
         let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let arg_ptr = WrapParamRef::<::std::os::raw::c_void>::from(arg_ptr);
-        let arg_ptr = arg_ptr.as_ref();
         let arg_size = arg_size.as_raw();
         let arg_n = arg_n.as_raw();
         arg_self_.interface.write(arg_ptr, arg_size, arg_n).into()
@@ -5837,7 +5829,7 @@ mod impl_cef_stream_writer_t {
 #[derive(Clone)]
 pub struct StreamWriter(RefGuard<_cef_stream_writer_t>);
 impl ImplStreamWriter for StreamWriter {
-    fn write(&self, ptr: &[::std::os::raw::c_void], size: usize, n: usize) -> usize {
+    fn write(&self, ptr: *const ::std::os::raw::c_void, size: usize, n: usize) -> usize {
         unsafe {
             self.0
                 .write
@@ -9040,7 +9032,7 @@ pub trait ImplPostDataElement: Sized {
     fn set_to_file(&self, file_name: &CefStringUtf16) {
         unsafe { std::mem::zeroed() }
     }
-    fn set_to_bytes(&self, size: usize, bytes: &[::std::os::raw::c_void]) {
+    fn set_to_bytes(&self, size: usize, bytes: *const ::std::os::raw::c_void) {
         unsafe { std::mem::zeroed() }
     }
     fn get_type(&self) -> PostdataelementType {
@@ -9052,7 +9044,7 @@ pub trait ImplPostDataElement: Sized {
     fn get_bytes_count(&self) -> usize {
         unsafe { std::mem::zeroed() }
     }
-    fn get_bytes(&self, size: usize, bytes: &mut ::std::os::raw::c_void) -> usize {
+    fn get_bytes(&self, size: usize, bytes: *mut ::std::os::raw::c_void) -> usize {
         unsafe { std::mem::zeroed() }
     }
     fn into_raw(self) -> *mut _cef_post_data_element_t {
@@ -9103,8 +9095,6 @@ mod impl_cef_post_data_element_t {
         let (arg_self_, arg_size, arg_bytes) = (self_, size, bytes);
         let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
         let arg_size = arg_size.as_raw();
-        let arg_bytes = WrapParamRef::<::std::os::raw::c_void>::from(arg_bytes);
-        let arg_bytes = arg_bytes.as_ref();
         arg_self_.interface.set_to_bytes(arg_size, arg_bytes)
     }
     extern "C" fn get_type<I: ImplPostDataElement>(
@@ -9136,8 +9126,6 @@ mod impl_cef_post_data_element_t {
         let (arg_self_, arg_size, arg_bytes) = (self_, size, bytes);
         let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
         let arg_size = arg_size.as_raw();
-        let mut arg_bytes = WrapParamRef::<::std::os::raw::c_void>::from(arg_bytes);
-        let arg_bytes = arg_bytes.as_mut();
         arg_self_.interface.get_bytes(arg_size, arg_bytes).into()
     }
 }
@@ -9183,7 +9171,7 @@ impl ImplPostDataElement for PostDataElement {
                 .unwrap_or_else(|| std::mem::zeroed())
         }
     }
-    fn set_to_bytes(&self, size: usize, bytes: &[::std::os::raw::c_void]) {
+    fn set_to_bytes(&self, size: usize, bytes: *const ::std::os::raw::c_void) {
         unsafe {
             self.0
                 .set_to_bytes
@@ -9234,7 +9222,7 @@ impl ImplPostDataElement for PostDataElement {
                 .unwrap_or_else(|| std::mem::zeroed())
         }
     }
-    fn get_bytes(&self, size: usize, bytes: &mut ::std::os::raw::c_void) -> usize {
+    fn get_bytes(&self, size: usize, bytes: *mut ::std::os::raw::c_void) -> usize {
         unsafe {
             self.0
                 .get_bytes
@@ -9365,82 +9353,6 @@ impl Default for CefStringVisitor {
         unsafe { std::mem::zeroed() }
     }
 }
-#[doc = "See [_cef_urlrequest_client_t] for more documentation."]
-#[repr(transparent)]
-pub struct UrlrequestClient(_cef_urlrequest_client_t);
-impl From<_cef_urlrequest_client_t> for UrlrequestClient {
-    fn from(value: _cef_urlrequest_client_t) -> Self {
-        Self(value)
-    }
-}
-impl Into<*const _cef_urlrequest_client_t> for &UrlrequestClient {
-    fn into(self) -> *const _cef_urlrequest_client_t {
-        self.as_ref() as *const _cef_urlrequest_client_t
-    }
-}
-impl Into<*mut _cef_urlrequest_client_t> for &mut UrlrequestClient {
-    fn into(self) -> *mut _cef_urlrequest_client_t {
-        self.as_mut() as *mut _cef_urlrequest_client_t
-    }
-}
-impl Into<_cef_urlrequest_client_t> for UrlrequestClient {
-    fn into(self) -> _cef_urlrequest_client_t {
-        self.0
-    }
-}
-impl AsRef<_cef_urlrequest_client_t> for UrlrequestClient {
-    fn as_ref(&self) -> &_cef_urlrequest_client_t {
-        &self.0
-    }
-}
-impl AsMut<_cef_urlrequest_client_t> for UrlrequestClient {
-    fn as_mut(&mut self) -> &mut _cef_urlrequest_client_t {
-        &mut self.0
-    }
-}
-impl Default for UrlrequestClient {
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
-#[doc = "See [_cef_urlrequest_t] for more documentation."]
-#[repr(transparent)]
-pub struct Urlrequest(_cef_urlrequest_t);
-impl From<_cef_urlrequest_t> for Urlrequest {
-    fn from(value: _cef_urlrequest_t) -> Self {
-        Self(value)
-    }
-}
-impl Into<*const _cef_urlrequest_t> for &Urlrequest {
-    fn into(self) -> *const _cef_urlrequest_t {
-        self.as_ref() as *const _cef_urlrequest_t
-    }
-}
-impl Into<*mut _cef_urlrequest_t> for &mut Urlrequest {
-    fn into(self) -> *mut _cef_urlrequest_t {
-        self.as_mut() as *mut _cef_urlrequest_t
-    }
-}
-impl Into<_cef_urlrequest_t> for Urlrequest {
-    fn into(self) -> _cef_urlrequest_t {
-        self.0
-    }
-}
-impl AsRef<_cef_urlrequest_t> for Urlrequest {
-    fn as_ref(&self) -> &_cef_urlrequest_t {
-        &self.0
-    }
-}
-impl AsMut<_cef_urlrequest_t> for Urlrequest {
-    fn as_mut(&mut self) -> &mut _cef_urlrequest_t {
-        &mut self.0
-    }
-}
-impl Default for Urlrequest {
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
 pub trait ImplFrame: Sized {
     fn is_valid(&self) -> ::std::os::raw::c_int {
         unsafe { std::mem::zeroed() }
@@ -9729,8 +9641,7 @@ mod impl_cef_frame_t {
         let (arg_self_, arg_request, arg_client) = (self_, request, client);
         let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
         let arg_request = &mut Request(unsafe { RefGuard::from_raw_add_ref(arg_request) });
-        let mut arg_client = WrapParamRef::<UrlrequestClient>::from(arg_client);
-        let arg_client = arg_client.as_mut();
+        let arg_client = &mut UrlrequestClient(unsafe { RefGuard::from_raw_add_ref(arg_client) });
         arg_self_
             .interface
             .create_urlrequest(arg_request, arg_client)
@@ -27004,7 +26915,7 @@ pub trait ImplRenderHandler: Sized {
         type_: PaintElementType,
         dirty_rects_count: usize,
         dirty_rects: &Rect,
-        buffer: &[::std::os::raw::c_void],
+        buffer: *const ::std::os::raw::c_void,
         width: ::std::os::raw::c_int,
         height: ::std::os::raw::c_int,
     ) {
@@ -27230,8 +27141,6 @@ mod impl_cef_render_handler_t {
         let arg_dirty_rects_count = arg_dirty_rects_count.as_raw();
         let arg_dirty_rects = WrapParamRef::<Rect>::from(arg_dirty_rects);
         let arg_dirty_rects = arg_dirty_rects.as_ref();
-        let arg_buffer = WrapParamRef::<::std::os::raw::c_void>::from(arg_buffer);
-        let arg_buffer = arg_buffer.as_ref();
         let arg_width = arg_width.as_raw();
         let arg_height = arg_height.as_raw();
         arg_self_.interface.on_paint(
@@ -27556,7 +27465,7 @@ impl ImplRenderHandler for RenderHandler {
         type_: PaintElementType,
         dirty_rects_count: usize,
         dirty_rects: &Rect,
-        buffer: &[::std::os::raw::c_void],
+        buffer: *const ::std::os::raw::c_void,
         width: ::std::os::raw::c_int,
         height: ::std::os::raw::c_int,
     ) {
@@ -28656,7 +28565,7 @@ pub trait ImplResourceHandler: Sized {
     }
     fn read(
         &self,
-        data_out: &mut ::std::os::raw::c_void,
+        data_out: *mut ::std::os::raw::c_void,
         bytes_to_read: ::std::os::raw::c_int,
         bytes_read: &mut ::std::os::raw::c_int,
         callback: &mut ResourceReadCallback,
@@ -28665,7 +28574,7 @@ pub trait ImplResourceHandler: Sized {
     }
     fn read_response(
         &self,
-        data_out: &mut ::std::os::raw::c_void,
+        data_out: *mut ::std::os::raw::c_void,
         bytes_to_read: ::std::os::raw::c_int,
         bytes_read: &mut ::std::os::raw::c_int,
         callback: &mut Callback,
@@ -28774,8 +28683,6 @@ mod impl_cef_resource_handler_t {
         let (arg_self_, arg_data_out, arg_bytes_to_read, arg_bytes_read, arg_callback) =
             (self_, data_out, bytes_to_read, bytes_read, callback);
         let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let mut arg_data_out = WrapParamRef::<::std::os::raw::c_void>::from(arg_data_out);
-        let arg_data_out = arg_data_out.as_mut();
         let arg_bytes_to_read = arg_bytes_to_read.as_raw();
         let mut arg_bytes_read = WrapParamRef::<::std::os::raw::c_int>::from(arg_bytes_read);
         let arg_bytes_read = arg_bytes_read.as_mut();
@@ -28801,8 +28708,6 @@ mod impl_cef_resource_handler_t {
         let (arg_self_, arg_data_out, arg_bytes_to_read, arg_bytes_read, arg_callback) =
             (self_, data_out, bytes_to_read, bytes_read, callback);
         let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let mut arg_data_out = WrapParamRef::<::std::os::raw::c_void>::from(arg_data_out);
-        let arg_data_out = arg_data_out.as_mut();
         let arg_bytes_to_read = arg_bytes_to_read.as_raw();
         let mut arg_bytes_read = WrapParamRef::<::std::os::raw::c_int>::from(arg_bytes_read);
         let arg_bytes_read = arg_bytes_read.as_mut();
@@ -28924,7 +28829,7 @@ impl ImplResourceHandler for ResourceHandler {
     }
     fn read(
         &self,
-        data_out: &mut ::std::os::raw::c_void,
+        data_out: *mut ::std::os::raw::c_void,
         bytes_to_read: ::std::os::raw::c_int,
         bytes_read: &mut ::std::os::raw::c_int,
         callback: &mut ResourceReadCallback,
@@ -28954,7 +28859,7 @@ impl ImplResourceHandler for ResourceHandler {
     }
     fn read_response(
         &self,
-        data_out: &mut ::std::os::raw::c_void,
+        data_out: *mut ::std::os::raw::c_void,
         bytes_to_read: ::std::os::raw::c_int,
         bytes_read: &mut ::std::os::raw::c_int,
         callback: &mut Callback,
@@ -34042,7 +33947,7 @@ impl Default for V8exception {
     }
 }
 pub trait ImplV8arrayBufferReleaseCallback: Sized {
-    fn release_buffer(&self, buffer: &mut ::std::os::raw::c_void) {
+    fn release_buffer(&self, buffer: *mut ::std::os::raw::c_void) {
         unsafe { std::mem::zeroed() }
     }
     fn into_raw(self) -> *mut _cef_v8array_buffer_release_callback_t {
@@ -34064,8 +33969,6 @@ mod impl_cef_v8array_buffer_release_callback_t {
     ) {
         let (arg_self_, arg_buffer) = (self_, buffer);
         let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let mut arg_buffer = WrapParamRef::<::std::os::raw::c_void>::from(arg_buffer);
-        let arg_buffer = arg_buffer.as_mut();
         arg_self_.interface.release_buffer(arg_buffer)
     }
 }
@@ -34073,7 +33976,7 @@ mod impl_cef_v8array_buffer_release_callback_t {
 #[derive(Clone)]
 pub struct V8arrayBufferReleaseCallback(RefGuard<_cef_v8array_buffer_release_callback_t>);
 impl ImplV8arrayBufferReleaseCallback for V8arrayBufferReleaseCallback {
-    fn release_buffer(&self, buffer: &mut ::std::os::raw::c_void) {
+    fn release_buffer(&self, buffer: *mut ::std::os::raw::c_void) {
         unsafe {
             self.0
                 .release_buffer
@@ -36921,6 +36824,772 @@ impl Default for App {
         unsafe { std::mem::zeroed() }
     }
 }
+pub trait ImplUrlrequest: Sized {
+    fn get_request(&self) -> Request {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_client(&self) -> UrlrequestClient {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_request_status(&self) -> UrlrequestStatus {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_request_error(&self) -> Errorcode {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_response(&self) -> Response {
+        unsafe { std::mem::zeroed() }
+    }
+    fn response_was_cached(&self) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn cancel(&self) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_urlrequest_t {
+        let mut object: _cef_urlrequest_t = unsafe { std::mem::zeroed() };
+        impl_cef_urlrequest_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_urlrequest_t {
+    use super::*;
+    pub fn init_methods<I: ImplUrlrequest>(object: &mut _cef_urlrequest_t) {
+        object.get_request = Some(get_request::<I>);
+        object.get_client = Some(get_client::<I>);
+        object.get_request_status = Some(get_request_status::<I>);
+        object.get_request_error = Some(get_request_error::<I>);
+        object.get_response = Some(get_response::<I>);
+        object.response_was_cached = Some(response_was_cached::<I>);
+        object.cancel = Some(cancel::<I>);
+    }
+    extern "C" fn get_request<I: ImplUrlrequest>(
+        self_: *mut _cef_urlrequest_t,
+    ) -> *mut _cef_request_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_request().into()
+    }
+    extern "C" fn get_client<I: ImplUrlrequest>(
+        self_: *mut _cef_urlrequest_t,
+    ) -> *mut _cef_urlrequest_client_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_client().into()
+    }
+    extern "C" fn get_request_status<I: ImplUrlrequest>(
+        self_: *mut _cef_urlrequest_t,
+    ) -> cef_urlrequest_status_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_request_status().into()
+    }
+    extern "C" fn get_request_error<I: ImplUrlrequest>(
+        self_: *mut _cef_urlrequest_t,
+    ) -> cef_errorcode_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_request_error().into()
+    }
+    extern "C" fn get_response<I: ImplUrlrequest>(
+        self_: *mut _cef_urlrequest_t,
+    ) -> *mut _cef_response_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_response().into()
+    }
+    extern "C" fn response_was_cached<I: ImplUrlrequest>(
+        self_: *mut _cef_urlrequest_t,
+    ) -> ::std::os::raw::c_int {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.response_was_cached().into()
+    }
+    extern "C" fn cancel<I: ImplUrlrequest>(self_: *mut _cef_urlrequest_t) {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.cancel()
+    }
+}
+#[doc = "See [_cef_urlrequest_t] for more documentation."]
+#[derive(Clone)]
+pub struct Urlrequest(RefGuard<_cef_urlrequest_t>);
+impl ImplUrlrequest for Urlrequest {
+    fn get_request(&self) -> Request {
+        unsafe {
+            self.0
+                .get_request
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_client(&self) -> UrlrequestClient {
+        unsafe {
+            self.0
+                .get_client
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_request_status(&self) -> UrlrequestStatus {
+        unsafe {
+            self.0
+                .get_request_status
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_request_error(&self) -> Errorcode {
+        unsafe {
+            self.0
+                .get_request_error
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_response(&self) -> Response {
+        unsafe {
+            self.0
+                .get_response
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn response_was_cached(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .response_was_cached
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn cancel(&self) {
+        unsafe {
+            self.0
+                .cancel
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_urlrequest_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for Urlrequest {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_urlrequest_t> for &Urlrequest {
+    fn as_raw(self) -> *mut _cef_urlrequest_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_urlrequest_t> for &mut Urlrequest {
+    fn as_raw(self) -> *mut _cef_urlrequest_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<Urlrequest> for *mut _cef_urlrequest_t {
+    fn as_wrapper(self) -> Urlrequest {
+        Urlrequest(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_urlrequest_t> for Urlrequest {
+    fn into(self) -> *mut _cef_urlrequest_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for Urlrequest {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplUrlrequestClient: Sized {
+    fn on_request_complete(&self, request: &mut Urlrequest) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn on_upload_progress(&self, request: &mut Urlrequest, current: i64, total: i64) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn on_download_progress(&self, request: &mut Urlrequest, current: i64, total: i64) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn on_download_data(
+        &self,
+        request: &mut Urlrequest,
+        data: *const ::std::os::raw::c_void,
+        data_length: usize,
+    ) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_auth_credentials(
+        &self,
+        is_proxy: ::std::os::raw::c_int,
+        host: &CefStringUtf16,
+        port: ::std::os::raw::c_int,
+        realm: &CefStringUtf16,
+        scheme: &CefStringUtf16,
+        callback: &mut AuthCallback,
+    ) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_urlrequest_client_t {
+        let mut object: _cef_urlrequest_client_t = unsafe { std::mem::zeroed() };
+        impl_cef_urlrequest_client_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_urlrequest_client_t {
+    use super::*;
+    pub fn init_methods<I: ImplUrlrequestClient>(object: &mut _cef_urlrequest_client_t) {
+        object.on_request_complete = Some(on_request_complete::<I>);
+        object.on_upload_progress = Some(on_upload_progress::<I>);
+        object.on_download_progress = Some(on_download_progress::<I>);
+        object.on_download_data = Some(on_download_data::<I>);
+        object.get_auth_credentials = Some(get_auth_credentials::<I>);
+    }
+    extern "C" fn on_request_complete<I: ImplUrlrequestClient>(
+        self_: *mut _cef_urlrequest_client_t,
+        request: *mut _cef_urlrequest_t,
+    ) {
+        let (arg_self_, arg_request) = (self_, request);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_request = &mut Urlrequest(unsafe { RefGuard::from_raw_add_ref(arg_request) });
+        arg_self_.interface.on_request_complete(arg_request)
+    }
+    extern "C" fn on_upload_progress<I: ImplUrlrequestClient>(
+        self_: *mut _cef_urlrequest_client_t,
+        request: *mut _cef_urlrequest_t,
+        current: i64,
+        total: i64,
+    ) {
+        let (arg_self_, arg_request, arg_current, arg_total) = (self_, request, current, total);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_request = &mut Urlrequest(unsafe { RefGuard::from_raw_add_ref(arg_request) });
+        let arg_current = arg_current.as_raw();
+        let arg_total = arg_total.as_raw();
+        arg_self_
+            .interface
+            .on_upload_progress(arg_request, arg_current, arg_total)
+    }
+    extern "C" fn on_download_progress<I: ImplUrlrequestClient>(
+        self_: *mut _cef_urlrequest_client_t,
+        request: *mut _cef_urlrequest_t,
+        current: i64,
+        total: i64,
+    ) {
+        let (arg_self_, arg_request, arg_current, arg_total) = (self_, request, current, total);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_request = &mut Urlrequest(unsafe { RefGuard::from_raw_add_ref(arg_request) });
+        let arg_current = arg_current.as_raw();
+        let arg_total = arg_total.as_raw();
+        arg_self_
+            .interface
+            .on_download_progress(arg_request, arg_current, arg_total)
+    }
+    extern "C" fn on_download_data<I: ImplUrlrequestClient>(
+        self_: *mut _cef_urlrequest_client_t,
+        request: *mut _cef_urlrequest_t,
+        data: *const ::std::os::raw::c_void,
+        data_length: usize,
+    ) {
+        let (arg_self_, arg_request, arg_data, arg_data_length) =
+            (self_, request, data, data_length);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_request = &mut Urlrequest(unsafe { RefGuard::from_raw_add_ref(arg_request) });
+        let arg_data_length = arg_data_length.as_raw();
+        arg_self_
+            .interface
+            .on_download_data(arg_request, arg_data, arg_data_length)
+    }
+    extern "C" fn get_auth_credentials<I: ImplUrlrequestClient>(
+        self_: *mut _cef_urlrequest_client_t,
+        is_proxy: ::std::os::raw::c_int,
+        host: *const _cef_string_utf16_t,
+        port: ::std::os::raw::c_int,
+        realm: *const _cef_string_utf16_t,
+        scheme: *const _cef_string_utf16_t,
+        callback: *mut _cef_auth_callback_t,
+    ) -> ::std::os::raw::c_int {
+        let (arg_self_, arg_is_proxy, arg_host, arg_port, arg_realm, arg_scheme, arg_callback) =
+            (self_, is_proxy, host, port, realm, scheme, callback);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_is_proxy = arg_is_proxy.as_raw();
+        let arg_host = WrapParamRef::<CefStringUtf16>::from(arg_host);
+        let arg_host = arg_host.as_ref();
+        let arg_port = arg_port.as_raw();
+        let arg_realm = WrapParamRef::<CefStringUtf16>::from(arg_realm);
+        let arg_realm = arg_realm.as_ref();
+        let arg_scheme = WrapParamRef::<CefStringUtf16>::from(arg_scheme);
+        let arg_scheme = arg_scheme.as_ref();
+        let arg_callback = &mut AuthCallback(unsafe { RefGuard::from_raw_add_ref(arg_callback) });
+        arg_self_
+            .interface
+            .get_auth_credentials(
+                arg_is_proxy,
+                arg_host,
+                arg_port,
+                arg_realm,
+                arg_scheme,
+                arg_callback,
+            )
+            .into()
+    }
+}
+#[doc = "See [_cef_urlrequest_client_t] for more documentation."]
+#[derive(Clone)]
+pub struct UrlrequestClient(RefGuard<_cef_urlrequest_client_t>);
+impl ImplUrlrequestClient for UrlrequestClient {
+    fn on_request_complete(&self, request: &mut Urlrequest) {
+        unsafe {
+            self.0
+                .on_request_complete
+                .map(|f| {
+                    let arg_request = request;
+                    let arg_self_ = self.as_raw();
+                    let arg_request = arg_request.as_raw();
+                    let result = f(arg_self_, arg_request);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn on_upload_progress(&self, request: &mut Urlrequest, current: i64, total: i64) {
+        unsafe {
+            self.0
+                .on_upload_progress
+                .map(|f| {
+                    let (arg_request, arg_current, arg_total) = (request, current, total);
+                    let arg_self_ = self.as_raw();
+                    let arg_request = arg_request.as_raw();
+                    let arg_current = arg_current;
+                    let arg_total = arg_total;
+                    let result = f(arg_self_, arg_request, arg_current, arg_total);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn on_download_progress(&self, request: &mut Urlrequest, current: i64, total: i64) {
+        unsafe {
+            self.0
+                .on_download_progress
+                .map(|f| {
+                    let (arg_request, arg_current, arg_total) = (request, current, total);
+                    let arg_self_ = self.as_raw();
+                    let arg_request = arg_request.as_raw();
+                    let arg_current = arg_current;
+                    let arg_total = arg_total;
+                    let result = f(arg_self_, arg_request, arg_current, arg_total);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn on_download_data(
+        &self,
+        request: &mut Urlrequest,
+        data: *const ::std::os::raw::c_void,
+        data_length: usize,
+    ) {
+        unsafe {
+            self.0
+                .on_download_data
+                .map(|f| {
+                    let (arg_request, arg_data, arg_data_length) = (request, data, data_length);
+                    let arg_self_ = self.as_raw();
+                    let arg_request = arg_request.as_raw();
+                    let arg_data = arg_data as *const _;
+                    let arg_data_length = arg_data_length;
+                    let result = f(arg_self_, arg_request, arg_data, arg_data_length);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_auth_credentials(
+        &self,
+        is_proxy: ::std::os::raw::c_int,
+        host: &CefStringUtf16,
+        port: ::std::os::raw::c_int,
+        realm: &CefStringUtf16,
+        scheme: &CefStringUtf16,
+        callback: &mut AuthCallback,
+    ) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .get_auth_credentials
+                .map(|f| {
+                    let (arg_is_proxy, arg_host, arg_port, arg_realm, arg_scheme, arg_callback) =
+                        (is_proxy, host, port, realm, scheme, callback);
+                    let arg_self_ = self.as_raw();
+                    let arg_is_proxy = arg_is_proxy;
+                    let arg_host = arg_host.as_raw();
+                    let arg_port = arg_port;
+                    let arg_realm = arg_realm.as_raw();
+                    let arg_scheme = arg_scheme.as_raw();
+                    let arg_callback = arg_callback.as_raw();
+                    let result = f(
+                        arg_self_,
+                        arg_is_proxy,
+                        arg_host,
+                        arg_port,
+                        arg_realm,
+                        arg_scheme,
+                        arg_callback,
+                    );
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_urlrequest_client_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for UrlrequestClient {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_urlrequest_client_t> for &UrlrequestClient {
+    fn as_raw(self) -> *mut _cef_urlrequest_client_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_urlrequest_client_t> for &mut UrlrequestClient {
+    fn as_raw(self) -> *mut _cef_urlrequest_client_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<UrlrequestClient> for *mut _cef_urlrequest_client_t {
+    fn as_wrapper(self) -> UrlrequestClient {
+        UrlrequestClient(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_urlrequest_client_t> for UrlrequestClient {
+    fn into(self) -> *mut _cef_urlrequest_client_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for UrlrequestClient {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplLayout: Sized {
+    fn as_box_layout(&self) -> BoxLayout {
+        unsafe { std::mem::zeroed() }
+    }
+    fn as_fill_layout(&self) -> FillLayout {
+        unsafe { std::mem::zeroed() }
+    }
+    fn is_valid(&self) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_layout_t {
+        let mut object: _cef_layout_t = unsafe { std::mem::zeroed() };
+        impl_cef_layout_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_layout_t {
+    use super::*;
+    pub fn init_methods<I: ImplLayout>(object: &mut _cef_layout_t) {
+        object.as_box_layout = Some(as_box_layout::<I>);
+        object.as_fill_layout = Some(as_fill_layout::<I>);
+        object.is_valid = Some(is_valid::<I>);
+    }
+    extern "C" fn as_box_layout<I: ImplLayout>(
+        self_: *mut _cef_layout_t,
+    ) -> *mut _cef_box_layout_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.as_box_layout().into()
+    }
+    extern "C" fn as_fill_layout<I: ImplLayout>(
+        self_: *mut _cef_layout_t,
+    ) -> *mut _cef_fill_layout_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.as_fill_layout().into()
+    }
+    extern "C" fn is_valid<I: ImplLayout>(self_: *mut _cef_layout_t) -> ::std::os::raw::c_int {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.is_valid().into()
+    }
+}
+#[doc = "See [_cef_layout_t] for more documentation."]
+#[derive(Clone)]
+pub struct Layout(RefGuard<_cef_layout_t>);
+impl ImplLayout for Layout {
+    fn as_box_layout(&self) -> BoxLayout {
+        unsafe {
+            self.0
+                .as_box_layout
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn as_fill_layout(&self) -> FillLayout {
+        unsafe {
+            self.0
+                .as_fill_layout
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn is_valid(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .is_valid
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_layout_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for Layout {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_layout_t> for &Layout {
+    fn as_raw(self) -> *mut _cef_layout_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_layout_t> for &mut Layout {
+    fn as_raw(self) -> *mut _cef_layout_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<Layout> for *mut _cef_layout_t {
+    fn as_wrapper(self) -> Layout {
+        Layout(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_layout_t> for Layout {
+    fn into(self) -> *mut _cef_layout_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for Layout {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplBoxLayout: ImplLayout {
+    fn set_flex_for_view(&self, view: &mut View, flex: ::std::os::raw::c_int) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn clear_flex_for_view(&self, view: &mut View) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_box_layout_t {
+        let mut object: _cef_box_layout_t = unsafe { std::mem::zeroed() };
+        impl_cef_layout_t::init_methods::<Self>(&mut object.base);
+        impl_cef_box_layout_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_box_layout_t {
+    use super::*;
+    pub fn init_methods<I: ImplBoxLayout>(object: &mut _cef_box_layout_t) {
+        object.set_flex_for_view = Some(set_flex_for_view::<I>);
+        object.clear_flex_for_view = Some(clear_flex_for_view::<I>);
+    }
+    extern "C" fn set_flex_for_view<I: ImplBoxLayout>(
+        self_: *mut _cef_box_layout_t,
+        view: *mut _cef_view_t,
+        flex: ::std::os::raw::c_int,
+    ) {
+        let (arg_self_, arg_view, arg_flex) = (self_, view, flex);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_view = &mut View(unsafe { RefGuard::from_raw_add_ref(arg_view) });
+        let arg_flex = arg_flex.as_raw();
+        arg_self_.interface.set_flex_for_view(arg_view, arg_flex)
+    }
+    extern "C" fn clear_flex_for_view<I: ImplBoxLayout>(
+        self_: *mut _cef_box_layout_t,
+        view: *mut _cef_view_t,
+    ) {
+        let (arg_self_, arg_view) = (self_, view);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_view = &mut View(unsafe { RefGuard::from_raw_add_ref(arg_view) });
+        arg_self_.interface.clear_flex_for_view(arg_view)
+    }
+}
+#[doc = "See [_cef_box_layout_t] for more documentation."]
+#[derive(Clone)]
+pub struct BoxLayout(RefGuard<_cef_box_layout_t>);
+impl ImplBoxLayout for BoxLayout {
+    fn set_flex_for_view(&self, view: &mut View, flex: ::std::os::raw::c_int) {
+        unsafe {
+            self.0
+                .set_flex_for_view
+                .map(|f| {
+                    let (arg_view, arg_flex) = (view, flex);
+                    let arg_self_ = self.as_raw();
+                    let arg_view = arg_view.as_raw();
+                    let arg_flex = arg_flex;
+                    let result = f(arg_self_, arg_view, arg_flex);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn clear_flex_for_view(&self, view: &mut View) {
+        unsafe {
+            self.0
+                .clear_flex_for_view
+                .map(|f| {
+                    let arg_view = view;
+                    let arg_self_ = self.as_raw();
+                    let arg_view = arg_view.as_raw();
+                    let result = f(arg_self_, arg_view);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_box_layout_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for BoxLayout {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_box_layout_t> for &BoxLayout {
+    fn as_raw(self) -> *mut _cef_box_layout_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_box_layout_t> for &mut BoxLayout {
+    fn as_raw(self) -> *mut _cef_box_layout_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<BoxLayout> for *mut _cef_box_layout_t {
+    fn as_wrapper(self) -> BoxLayout {
+        BoxLayout(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_box_layout_t> for BoxLayout {
+    fn into(self) -> *mut _cef_box_layout_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for BoxLayout {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplFillLayout: ImplLayout {
+    fn into_raw(self) -> *mut _cef_fill_layout_t {
+        let mut object: _cef_fill_layout_t = unsafe { std::mem::zeroed() };
+        impl_cef_layout_t::init_methods::<Self>(&mut object.base);
+        impl_cef_fill_layout_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_fill_layout_t {
+    use super::*;
+    pub fn init_methods<I: ImplFillLayout>(object: &mut _cef_fill_layout_t) {}
+}
+#[doc = "See [_cef_fill_layout_t] for more documentation."]
+#[derive(Clone)]
+pub struct FillLayout(RefGuard<_cef_fill_layout_t>);
+impl ImplFillLayout for FillLayout {}
+impl Rc for _cef_fill_layout_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for FillLayout {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_fill_layout_t> for &FillLayout {
+    fn as_raw(self) -> *mut _cef_fill_layout_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_fill_layout_t> for &mut FillLayout {
+    fn as_raw(self) -> *mut _cef_fill_layout_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<FillLayout> for *mut _cef_fill_layout_t {
+    fn as_wrapper(self) -> FillLayout {
+        FillLayout(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_fill_layout_t> for FillLayout {
+    fn into(self) -> *mut _cef_fill_layout_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for FillLayout {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
 pub trait ImplViewDelegate: Sized {
     fn get_preferred_size(&self, view: &mut View) -> Size {
         unsafe { std::mem::zeroed() }
@@ -37329,499 +37998,6 @@ impl Default for ViewDelegate {
         unsafe { std::mem::zeroed() }
     }
 }
-pub trait ImplBrowserViewDelegate: ImplViewDelegate {
-    fn on_browser_created(&self, browser_view: &mut BrowserView, browser: &mut Browser) {
-        unsafe { std::mem::zeroed() }
-    }
-    fn on_browser_destroyed(&self, browser_view: &mut BrowserView, browser: &mut Browser) {
-        unsafe { std::mem::zeroed() }
-    }
-    fn get_delegate_for_popup_browser_view(
-        &self,
-        browser_view: &mut BrowserView,
-        settings: &BrowserSettings,
-        client: &mut Client,
-        is_devtools: ::std::os::raw::c_int,
-    ) -> BrowserViewDelegate {
-        unsafe { std::mem::zeroed() }
-    }
-    fn on_popup_browser_view_created(
-        &self,
-        browser_view: &mut BrowserView,
-        popup_browser_view: &mut BrowserView,
-        is_devtools: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        unsafe { std::mem::zeroed() }
-    }
-    fn get_chrome_toolbar_type(&self, browser_view: &mut BrowserView) -> ChromeToolbarType {
-        unsafe { std::mem::zeroed() }
-    }
-    fn use_frameless_window_for_picture_in_picture(
-        &self,
-        browser_view: &mut BrowserView,
-    ) -> ::std::os::raw::c_int {
-        unsafe { std::mem::zeroed() }
-    }
-    fn on_gesture_command(
-        &self,
-        browser_view: &mut BrowserView,
-        gesture_command: GestureCommand,
-    ) -> ::std::os::raw::c_int {
-        unsafe { std::mem::zeroed() }
-    }
-    fn get_browser_runtime_style(&self) -> RuntimeStyle {
-        unsafe { std::mem::zeroed() }
-    }
-    fn into_raw(self) -> *mut _cef_browser_view_delegate_t {
-        let mut object: _cef_browser_view_delegate_t = unsafe { std::mem::zeroed() };
-        impl_cef_view_delegate_t::init_methods::<Self>(&mut object.base);
-        impl_cef_browser_view_delegate_t::init_methods::<Self>(&mut object);
-        RcImpl::new(object, self) as *mut _
-    }
-}
-mod impl_cef_browser_view_delegate_t {
-    use super::*;
-    pub fn init_methods<I: ImplBrowserViewDelegate>(object: &mut _cef_browser_view_delegate_t) {
-        object.on_browser_created = Some(on_browser_created::<I>);
-        object.on_browser_destroyed = Some(on_browser_destroyed::<I>);
-        object.get_delegate_for_popup_browser_view = Some(get_delegate_for_popup_browser_view::<I>);
-        object.on_popup_browser_view_created = Some(on_popup_browser_view_created::<I>);
-        object.get_chrome_toolbar_type = Some(get_chrome_toolbar_type::<I>);
-        object.use_frameless_window_for_picture_in_picture =
-            Some(use_frameless_window_for_picture_in_picture::<I>);
-        object.on_gesture_command = Some(on_gesture_command::<I>);
-        object.get_browser_runtime_style = Some(get_browser_runtime_style::<I>);
-    }
-    extern "C" fn on_browser_created<I: ImplBrowserViewDelegate>(
-        self_: *mut _cef_browser_view_delegate_t,
-        browser_view: *mut _cef_browser_view_t,
-        browser: *mut _cef_browser_t,
-    ) {
-        let (arg_self_, arg_browser_view, arg_browser) = (self_, browser_view, browser);
-        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let arg_browser_view =
-            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
-        let arg_browser = &mut Browser(unsafe { RefGuard::from_raw_add_ref(arg_browser) });
-        arg_self_
-            .interface
-            .on_browser_created(arg_browser_view, arg_browser)
-    }
-    extern "C" fn on_browser_destroyed<I: ImplBrowserViewDelegate>(
-        self_: *mut _cef_browser_view_delegate_t,
-        browser_view: *mut _cef_browser_view_t,
-        browser: *mut _cef_browser_t,
-    ) {
-        let (arg_self_, arg_browser_view, arg_browser) = (self_, browser_view, browser);
-        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let arg_browser_view =
-            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
-        let arg_browser = &mut Browser(unsafe { RefGuard::from_raw_add_ref(arg_browser) });
-        arg_self_
-            .interface
-            .on_browser_destroyed(arg_browser_view, arg_browser)
-    }
-    extern "C" fn get_delegate_for_popup_browser_view<I: ImplBrowserViewDelegate>(
-        self_: *mut _cef_browser_view_delegate_t,
-        browser_view: *mut _cef_browser_view_t,
-        settings: *const _cef_browser_settings_t,
-        client: *mut _cef_client_t,
-        is_devtools: ::std::os::raw::c_int,
-    ) -> *mut _cef_browser_view_delegate_t {
-        let (arg_self_, arg_browser_view, arg_settings, arg_client, arg_is_devtools) =
-            (self_, browser_view, settings, client, is_devtools);
-        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let arg_browser_view =
-            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
-        let arg_settings = WrapParamRef::<BrowserSettings>::from(arg_settings);
-        let arg_settings = arg_settings.as_ref();
-        let arg_client = &mut Client(unsafe { RefGuard::from_raw_add_ref(arg_client) });
-        let arg_is_devtools = arg_is_devtools.as_raw();
-        arg_self_
-            .interface
-            .get_delegate_for_popup_browser_view(
-                arg_browser_view,
-                arg_settings,
-                arg_client,
-                arg_is_devtools,
-            )
-            .into()
-    }
-    extern "C" fn on_popup_browser_view_created<I: ImplBrowserViewDelegate>(
-        self_: *mut _cef_browser_view_delegate_t,
-        browser_view: *mut _cef_browser_view_t,
-        popup_browser_view: *mut _cef_browser_view_t,
-        is_devtools: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        let (arg_self_, arg_browser_view, arg_popup_browser_view, arg_is_devtools) =
-            (self_, browser_view, popup_browser_view, is_devtools);
-        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let arg_browser_view =
-            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
-        let arg_popup_browser_view =
-            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_popup_browser_view) });
-        let arg_is_devtools = arg_is_devtools.as_raw();
-        arg_self_
-            .interface
-            .on_popup_browser_view_created(
-                arg_browser_view,
-                arg_popup_browser_view,
-                arg_is_devtools,
-            )
-            .into()
-    }
-    extern "C" fn get_chrome_toolbar_type<I: ImplBrowserViewDelegate>(
-        self_: *mut _cef_browser_view_delegate_t,
-        browser_view: *mut _cef_browser_view_t,
-    ) -> cef_chrome_toolbar_type_t {
-        let (arg_self_, arg_browser_view) = (self_, browser_view);
-        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let arg_browser_view =
-            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
-        arg_self_
-            .interface
-            .get_chrome_toolbar_type(arg_browser_view)
-            .into()
-    }
-    extern "C" fn use_frameless_window_for_picture_in_picture<I: ImplBrowserViewDelegate>(
-        self_: *mut _cef_browser_view_delegate_t,
-        browser_view: *mut _cef_browser_view_t,
-    ) -> ::std::os::raw::c_int {
-        let (arg_self_, arg_browser_view) = (self_, browser_view);
-        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let arg_browser_view =
-            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
-        arg_self_
-            .interface
-            .use_frameless_window_for_picture_in_picture(arg_browser_view)
-            .into()
-    }
-    extern "C" fn on_gesture_command<I: ImplBrowserViewDelegate>(
-        self_: *mut _cef_browser_view_delegate_t,
-        browser_view: *mut _cef_browser_view_t,
-        gesture_command: cef_gesture_command_t,
-    ) -> ::std::os::raw::c_int {
-        let (arg_self_, arg_browser_view, arg_gesture_command) =
-            (self_, browser_view, gesture_command);
-        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        let arg_browser_view =
-            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
-        let arg_gesture_command = arg_gesture_command.as_raw();
-        arg_self_
-            .interface
-            .on_gesture_command(arg_browser_view, arg_gesture_command)
-            .into()
-    }
-    extern "C" fn get_browser_runtime_style<I: ImplBrowserViewDelegate>(
-        self_: *mut _cef_browser_view_delegate_t,
-    ) -> cef_runtime_style_t {
-        let arg_self_ = self_;
-        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
-        arg_self_.interface.get_browser_runtime_style().into()
-    }
-}
-#[doc = "See [_cef_browser_view_delegate_t] for more documentation."]
-#[derive(Clone)]
-pub struct BrowserViewDelegate(RefGuard<_cef_browser_view_delegate_t>);
-impl ImplBrowserViewDelegate for BrowserViewDelegate {
-    fn on_browser_created(&self, browser_view: &mut BrowserView, browser: &mut Browser) {
-        unsafe {
-            self.0
-                .on_browser_created
-                .map(|f| {
-                    let (arg_browser_view, arg_browser) = (browser_view, browser);
-                    let arg_self_ = self.as_raw();
-                    let arg_browser_view = arg_browser_view.as_raw();
-                    let arg_browser = arg_browser.as_raw();
-                    let result = f(arg_self_, arg_browser_view, arg_browser);
-                    result.as_wrapper()
-                })
-                .unwrap_or_else(|| std::mem::zeroed())
-        }
-    }
-    fn on_browser_destroyed(&self, browser_view: &mut BrowserView, browser: &mut Browser) {
-        unsafe {
-            self.0
-                .on_browser_destroyed
-                .map(|f| {
-                    let (arg_browser_view, arg_browser) = (browser_view, browser);
-                    let arg_self_ = self.as_raw();
-                    let arg_browser_view = arg_browser_view.as_raw();
-                    let arg_browser = arg_browser.as_raw();
-                    let result = f(arg_self_, arg_browser_view, arg_browser);
-                    result.as_wrapper()
-                })
-                .unwrap_or_else(|| std::mem::zeroed())
-        }
-    }
-    fn get_delegate_for_popup_browser_view(
-        &self,
-        browser_view: &mut BrowserView,
-        settings: &BrowserSettings,
-        client: &mut Client,
-        is_devtools: ::std::os::raw::c_int,
-    ) -> BrowserViewDelegate {
-        unsafe {
-            self.0
-                .get_delegate_for_popup_browser_view
-                .map(|f| {
-                    let (arg_browser_view, arg_settings, arg_client, arg_is_devtools) =
-                        (browser_view, settings, client, is_devtools);
-                    let arg_self_ = self.as_raw();
-                    let arg_browser_view = arg_browser_view.as_raw();
-                    let arg_settings = arg_settings.as_raw();
-                    let arg_client = arg_client.as_raw();
-                    let arg_is_devtools = arg_is_devtools;
-                    let result = f(
-                        arg_self_,
-                        arg_browser_view,
-                        arg_settings,
-                        arg_client,
-                        arg_is_devtools,
-                    );
-                    result.as_wrapper()
-                })
-                .unwrap_or_else(|| std::mem::zeroed())
-        }
-    }
-    fn on_popup_browser_view_created(
-        &self,
-        browser_view: &mut BrowserView,
-        popup_browser_view: &mut BrowserView,
-        is_devtools: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        unsafe {
-            self.0
-                .on_popup_browser_view_created
-                .map(|f| {
-                    let (arg_browser_view, arg_popup_browser_view, arg_is_devtools) =
-                        (browser_view, popup_browser_view, is_devtools);
-                    let arg_self_ = self.as_raw();
-                    let arg_browser_view = arg_browser_view.as_raw();
-                    let arg_popup_browser_view = arg_popup_browser_view.as_raw();
-                    let arg_is_devtools = arg_is_devtools;
-                    let result = f(
-                        arg_self_,
-                        arg_browser_view,
-                        arg_popup_browser_view,
-                        arg_is_devtools,
-                    );
-                    result.as_wrapper()
-                })
-                .unwrap_or_else(|| std::mem::zeroed())
-        }
-    }
-    fn get_chrome_toolbar_type(&self, browser_view: &mut BrowserView) -> ChromeToolbarType {
-        unsafe {
-            self.0
-                .get_chrome_toolbar_type
-                .map(|f| {
-                    let arg_browser_view = browser_view;
-                    let arg_self_ = self.as_raw();
-                    let arg_browser_view = arg_browser_view.as_raw();
-                    let result = f(arg_self_, arg_browser_view);
-                    result.as_wrapper()
-                })
-                .unwrap_or_else(|| std::mem::zeroed())
-        }
-    }
-    fn use_frameless_window_for_picture_in_picture(
-        &self,
-        browser_view: &mut BrowserView,
-    ) -> ::std::os::raw::c_int {
-        unsafe {
-            self.0
-                .use_frameless_window_for_picture_in_picture
-                .map(|f| {
-                    let arg_browser_view = browser_view;
-                    let arg_self_ = self.as_raw();
-                    let arg_browser_view = arg_browser_view.as_raw();
-                    let result = f(arg_self_, arg_browser_view);
-                    result.as_wrapper()
-                })
-                .unwrap_or_else(|| std::mem::zeroed())
-        }
-    }
-    fn on_gesture_command(
-        &self,
-        browser_view: &mut BrowserView,
-        gesture_command: GestureCommand,
-    ) -> ::std::os::raw::c_int {
-        unsafe {
-            self.0
-                .on_gesture_command
-                .map(|f| {
-                    let (arg_browser_view, arg_gesture_command) = (browser_view, gesture_command);
-                    let arg_self_ = self.as_raw();
-                    let arg_browser_view = arg_browser_view.as_raw();
-                    let arg_gesture_command = arg_gesture_command.as_raw();
-                    let result = f(arg_self_, arg_browser_view, arg_gesture_command);
-                    result.as_wrapper()
-                })
-                .unwrap_or_else(|| std::mem::zeroed())
-        }
-    }
-    fn get_browser_runtime_style(&self) -> RuntimeStyle {
-        unsafe {
-            self.0
-                .get_browser_runtime_style
-                .map(|f| {
-                    let arg_self_ = self.as_raw();
-                    let result = f(arg_self_);
-                    result.as_wrapper()
-                })
-                .unwrap_or_else(|| std::mem::zeroed())
-        }
-    }
-}
-impl Rc for _cef_browser_view_delegate_t {
-    fn as_base(&self) -> &_cef_base_ref_counted_t {
-        self.base.as_base()
-    }
-}
-impl Rc for BrowserViewDelegate {
-    fn as_base(&self) -> &_cef_base_ref_counted_t {
-        self.0.as_base()
-    }
-}
-impl ConvertParam<*mut _cef_browser_view_delegate_t> for &BrowserViewDelegate {
-    fn as_raw(self) -> *mut _cef_browser_view_delegate_t {
-        unsafe { (&self.0).as_raw() }
-    }
-}
-impl ConvertParam<*mut _cef_browser_view_delegate_t> for &mut BrowserViewDelegate {
-    fn as_raw(self) -> *mut _cef_browser_view_delegate_t {
-        unsafe { (&self.0).as_raw() }
-    }
-}
-impl ConvertReturnValue<BrowserViewDelegate> for *mut _cef_browser_view_delegate_t {
-    fn as_wrapper(self) -> BrowserViewDelegate {
-        BrowserViewDelegate(unsafe { RefGuard::from_raw(self) })
-    }
-}
-impl Into<*mut _cef_browser_view_delegate_t> for BrowserViewDelegate {
-    fn into(self) -> *mut _cef_browser_view_delegate_t {
-        unsafe { self.0.into_raw() }
-    }
-}
-impl Default for BrowserViewDelegate {
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
-#[doc = "See [_cef_button_t] for more documentation."]
-#[repr(transparent)]
-pub struct Button(_cef_button_t);
-impl From<_cef_button_t> for Button {
-    fn from(value: _cef_button_t) -> Self {
-        Self(value)
-    }
-}
-impl Into<*const _cef_button_t> for &Button {
-    fn into(self) -> *const _cef_button_t {
-        self.as_ref() as *const _cef_button_t
-    }
-}
-impl Into<*mut _cef_button_t> for &mut Button {
-    fn into(self) -> *mut _cef_button_t {
-        self.as_mut() as *mut _cef_button_t
-    }
-}
-impl Into<_cef_button_t> for Button {
-    fn into(self) -> _cef_button_t {
-        self.0
-    }
-}
-impl AsRef<_cef_button_t> for Button {
-    fn as_ref(&self) -> &_cef_button_t {
-        &self.0
-    }
-}
-impl AsMut<_cef_button_t> for Button {
-    fn as_mut(&mut self) -> &mut _cef_button_t {
-        &mut self.0
-    }
-}
-impl Default for Button {
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
-#[doc = "See [_cef_scroll_view_t] for more documentation."]
-#[repr(transparent)]
-pub struct ScrollView(_cef_scroll_view_t);
-impl From<_cef_scroll_view_t> for ScrollView {
-    fn from(value: _cef_scroll_view_t) -> Self {
-        Self(value)
-    }
-}
-impl Into<*const _cef_scroll_view_t> for &ScrollView {
-    fn into(self) -> *const _cef_scroll_view_t {
-        self.as_ref() as *const _cef_scroll_view_t
-    }
-}
-impl Into<*mut _cef_scroll_view_t> for &mut ScrollView {
-    fn into(self) -> *mut _cef_scroll_view_t {
-        self.as_mut() as *mut _cef_scroll_view_t
-    }
-}
-impl Into<_cef_scroll_view_t> for ScrollView {
-    fn into(self) -> _cef_scroll_view_t {
-        self.0
-    }
-}
-impl AsRef<_cef_scroll_view_t> for ScrollView {
-    fn as_ref(&self) -> &_cef_scroll_view_t {
-        &self.0
-    }
-}
-impl AsMut<_cef_scroll_view_t> for ScrollView {
-    fn as_mut(&mut self) -> &mut _cef_scroll_view_t {
-        &mut self.0
-    }
-}
-impl Default for ScrollView {
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
-#[doc = "See [_cef_textfield_t] for more documentation."]
-#[repr(transparent)]
-pub struct Textfield(_cef_textfield_t);
-impl From<_cef_textfield_t> for Textfield {
-    fn from(value: _cef_textfield_t) -> Self {
-        Self(value)
-    }
-}
-impl Into<*const _cef_textfield_t> for &Textfield {
-    fn into(self) -> *const _cef_textfield_t {
-        self.as_ref() as *const _cef_textfield_t
-    }
-}
-impl Into<*mut _cef_textfield_t> for &mut Textfield {
-    fn into(self) -> *mut _cef_textfield_t {
-        self.as_mut() as *mut _cef_textfield_t
-    }
-}
-impl Into<_cef_textfield_t> for Textfield {
-    fn into(self) -> _cef_textfield_t {
-        self.0
-    }
-}
-impl AsRef<_cef_textfield_t> for Textfield {
-    fn as_ref(&self) -> &_cef_textfield_t {
-        &self.0
-    }
-}
-impl AsMut<_cef_textfield_t> for Textfield {
-    fn as_mut(&mut self) -> &mut _cef_textfield_t {
-        &mut self.0
-    }
-}
-impl Default for Textfield {
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
 pub trait ImplView: Sized {
     fn as_browser_view(&self) -> BrowserView {
         unsafe { std::mem::zeroed() }
@@ -39117,6 +39293,2307 @@ impl Default for View {
         unsafe { std::mem::zeroed() }
     }
 }
+pub trait ImplButton: ImplView {
+    fn as_label_button(&self) -> LabelButton {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_state(&self, state: ButtonState) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_state(&self) -> ButtonState {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_ink_drop_enabled(&self, enabled: ::std::os::raw::c_int) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_tooltip_text(&self, tooltip_text: &CefStringUtf16) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_accessible_name(&self, name: &CefStringUtf16) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_button_t {
+        let mut object: _cef_button_t = unsafe { std::mem::zeroed() };
+        impl_cef_view_t::init_methods::<Self>(&mut object.base);
+        impl_cef_button_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_button_t {
+    use super::*;
+    pub fn init_methods<I: ImplButton>(object: &mut _cef_button_t) {
+        object.as_label_button = Some(as_label_button::<I>);
+        object.set_state = Some(set_state::<I>);
+        object.get_state = Some(get_state::<I>);
+        object.set_ink_drop_enabled = Some(set_ink_drop_enabled::<I>);
+        object.set_tooltip_text = Some(set_tooltip_text::<I>);
+        object.set_accessible_name = Some(set_accessible_name::<I>);
+    }
+    extern "C" fn as_label_button<I: ImplButton>(
+        self_: *mut _cef_button_t,
+    ) -> *mut _cef_label_button_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.as_label_button().into()
+    }
+    extern "C" fn set_state<I: ImplButton>(self_: *mut _cef_button_t, state: cef_button_state_t) {
+        let (arg_self_, arg_state) = (self_, state);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_state = arg_state.as_raw();
+        arg_self_.interface.set_state(arg_state)
+    }
+    extern "C" fn get_state<I: ImplButton>(self_: *mut _cef_button_t) -> cef_button_state_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_state().into()
+    }
+    extern "C" fn set_ink_drop_enabled<I: ImplButton>(
+        self_: *mut _cef_button_t,
+        enabled: ::std::os::raw::c_int,
+    ) {
+        let (arg_self_, arg_enabled) = (self_, enabled);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_enabled = arg_enabled.as_raw();
+        arg_self_.interface.set_ink_drop_enabled(arg_enabled)
+    }
+    extern "C" fn set_tooltip_text<I: ImplButton>(
+        self_: *mut _cef_button_t,
+        tooltip_text: *const _cef_string_utf16_t,
+    ) {
+        let (arg_self_, arg_tooltip_text) = (self_, tooltip_text);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_tooltip_text = WrapParamRef::<CefStringUtf16>::from(arg_tooltip_text);
+        let arg_tooltip_text = arg_tooltip_text.as_ref();
+        arg_self_.interface.set_tooltip_text(arg_tooltip_text)
+    }
+    extern "C" fn set_accessible_name<I: ImplButton>(
+        self_: *mut _cef_button_t,
+        name: *const _cef_string_utf16_t,
+    ) {
+        let (arg_self_, arg_name) = (self_, name);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_name = WrapParamRef::<CefStringUtf16>::from(arg_name);
+        let arg_name = arg_name.as_ref();
+        arg_self_.interface.set_accessible_name(arg_name)
+    }
+}
+#[doc = "See [_cef_button_t] for more documentation."]
+#[derive(Clone)]
+pub struct Button(RefGuard<_cef_button_t>);
+impl ImplButton for Button {
+    fn as_label_button(&self) -> LabelButton {
+        unsafe {
+            self.0
+                .as_label_button
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_state(&self, state: ButtonState) {
+        unsafe {
+            self.0
+                .set_state
+                .map(|f| {
+                    let arg_state = state;
+                    let arg_self_ = self.as_raw();
+                    let arg_state = arg_state.as_raw();
+                    let result = f(arg_self_, arg_state);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_state(&self) -> ButtonState {
+        unsafe {
+            self.0
+                .get_state
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_ink_drop_enabled(&self, enabled: ::std::os::raw::c_int) {
+        unsafe {
+            self.0
+                .set_ink_drop_enabled
+                .map(|f| {
+                    let arg_enabled = enabled;
+                    let arg_self_ = self.as_raw();
+                    let arg_enabled = arg_enabled;
+                    let result = f(arg_self_, arg_enabled);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_tooltip_text(&self, tooltip_text: &CefStringUtf16) {
+        unsafe {
+            self.0
+                .set_tooltip_text
+                .map(|f| {
+                    let arg_tooltip_text = tooltip_text;
+                    let arg_self_ = self.as_raw();
+                    let arg_tooltip_text = arg_tooltip_text.as_raw();
+                    let result = f(arg_self_, arg_tooltip_text);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_accessible_name(&self, name: &CefStringUtf16) {
+        unsafe {
+            self.0
+                .set_accessible_name
+                .map(|f| {
+                    let arg_name = name;
+                    let arg_self_ = self.as_raw();
+                    let arg_name = arg_name.as_raw();
+                    let result = f(arg_self_, arg_name);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_button_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for Button {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_button_t> for &Button {
+    fn as_raw(self) -> *mut _cef_button_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_button_t> for &mut Button {
+    fn as_raw(self) -> *mut _cef_button_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<Button> for *mut _cef_button_t {
+    fn as_wrapper(self) -> Button {
+        Button(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_button_t> for Button {
+    fn into(self) -> *mut _cef_button_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for Button {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplButtonDelegate: ImplViewDelegate {
+    fn on_button_pressed(&self, button: &mut Button) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn on_button_state_changed(&self, button: &mut Button) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_button_delegate_t {
+        let mut object: _cef_button_delegate_t = unsafe { std::mem::zeroed() };
+        impl_cef_view_delegate_t::init_methods::<Self>(&mut object.base);
+        impl_cef_button_delegate_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_button_delegate_t {
+    use super::*;
+    pub fn init_methods<I: ImplButtonDelegate>(object: &mut _cef_button_delegate_t) {
+        object.on_button_pressed = Some(on_button_pressed::<I>);
+        object.on_button_state_changed = Some(on_button_state_changed::<I>);
+    }
+    extern "C" fn on_button_pressed<I: ImplButtonDelegate>(
+        self_: *mut _cef_button_delegate_t,
+        button: *mut _cef_button_t,
+    ) {
+        let (arg_self_, arg_button) = (self_, button);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_button = &mut Button(unsafe { RefGuard::from_raw_add_ref(arg_button) });
+        arg_self_.interface.on_button_pressed(arg_button)
+    }
+    extern "C" fn on_button_state_changed<I: ImplButtonDelegate>(
+        self_: *mut _cef_button_delegate_t,
+        button: *mut _cef_button_t,
+    ) {
+        let (arg_self_, arg_button) = (self_, button);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_button = &mut Button(unsafe { RefGuard::from_raw_add_ref(arg_button) });
+        arg_self_.interface.on_button_state_changed(arg_button)
+    }
+}
+#[doc = "See [_cef_button_delegate_t] for more documentation."]
+#[derive(Clone)]
+pub struct ButtonDelegate(RefGuard<_cef_button_delegate_t>);
+impl ImplButtonDelegate for ButtonDelegate {
+    fn on_button_pressed(&self, button: &mut Button) {
+        unsafe {
+            self.0
+                .on_button_pressed
+                .map(|f| {
+                    let arg_button = button;
+                    let arg_self_ = self.as_raw();
+                    let arg_button = arg_button.as_raw();
+                    let result = f(arg_self_, arg_button);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn on_button_state_changed(&self, button: &mut Button) {
+        unsafe {
+            self.0
+                .on_button_state_changed
+                .map(|f| {
+                    let arg_button = button;
+                    let arg_self_ = self.as_raw();
+                    let arg_button = arg_button.as_raw();
+                    let result = f(arg_self_, arg_button);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_button_delegate_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for ButtonDelegate {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_button_delegate_t> for &ButtonDelegate {
+    fn as_raw(self) -> *mut _cef_button_delegate_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_button_delegate_t> for &mut ButtonDelegate {
+    fn as_raw(self) -> *mut _cef_button_delegate_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<ButtonDelegate> for *mut _cef_button_delegate_t {
+    fn as_wrapper(self) -> ButtonDelegate {
+        ButtonDelegate(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_button_delegate_t> for ButtonDelegate {
+    fn into(self) -> *mut _cef_button_delegate_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for ButtonDelegate {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplLabelButton: ImplButton {
+    fn as_menu_button(&self) -> MenuButton {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_text(&self, text: &CefStringUtf16) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_text(&self) -> CefStringUtf16 {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_image(&self, button_state: ButtonState, image: &mut Image) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_image(&self, button_state: ButtonState) -> Image {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_text_color(&self, for_state: ButtonState, color: u32) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_enabled_text_colors(&self, color: u32) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_font_list(&self, font_list: &CefStringUtf16) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_horizontal_alignment(&self, alignment: HorizontalAlignment) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_minimum_size(&self, size: &Size) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_maximum_size(&self, size: &Size) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_label_button_t {
+        let mut object: _cef_label_button_t = unsafe { std::mem::zeroed() };
+        impl_cef_view_t::init_methods::<Self>(&mut object.base.base);
+        impl_cef_button_t::init_methods::<Self>(&mut object.base);
+        impl_cef_label_button_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_label_button_t {
+    use super::*;
+    pub fn init_methods<I: ImplLabelButton>(object: &mut _cef_label_button_t) {
+        object.as_menu_button = Some(as_menu_button::<I>);
+        object.set_text = Some(set_text::<I>);
+        object.get_text = Some(get_text::<I>);
+        object.set_image = Some(set_image::<I>);
+        object.get_image = Some(get_image::<I>);
+        object.set_text_color = Some(set_text_color::<I>);
+        object.set_enabled_text_colors = Some(set_enabled_text_colors::<I>);
+        object.set_font_list = Some(set_font_list::<I>);
+        object.set_horizontal_alignment = Some(set_horizontal_alignment::<I>);
+        object.set_minimum_size = Some(set_minimum_size::<I>);
+        object.set_maximum_size = Some(set_maximum_size::<I>);
+    }
+    extern "C" fn as_menu_button<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+    ) -> *mut _cef_menu_button_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.as_menu_button().into()
+    }
+    extern "C" fn set_text<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+        text: *const _cef_string_utf16_t,
+    ) {
+        let (arg_self_, arg_text) = (self_, text);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_text = WrapParamRef::<CefStringUtf16>::from(arg_text);
+        let arg_text = arg_text.as_ref();
+        arg_self_.interface.set_text(arg_text)
+    }
+    extern "C" fn get_text<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+    ) -> *mut _cef_string_utf16_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_text().into()
+    }
+    extern "C" fn set_image<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+        button_state: cef_button_state_t,
+        image: *mut _cef_image_t,
+    ) {
+        let (arg_self_, arg_button_state, arg_image) = (self_, button_state, image);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_button_state = arg_button_state.as_raw();
+        let arg_image = &mut Image(unsafe { RefGuard::from_raw_add_ref(arg_image) });
+        arg_self_.interface.set_image(arg_button_state, arg_image)
+    }
+    extern "C" fn get_image<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+        button_state: cef_button_state_t,
+    ) -> *mut _cef_image_t {
+        let (arg_self_, arg_button_state) = (self_, button_state);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_button_state = arg_button_state.as_raw();
+        arg_self_.interface.get_image(arg_button_state).into()
+    }
+    extern "C" fn set_text_color<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+        for_state: cef_button_state_t,
+        color: u32,
+    ) {
+        let (arg_self_, arg_for_state, arg_color) = (self_, for_state, color);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_for_state = arg_for_state.as_raw();
+        let arg_color = arg_color.as_raw();
+        arg_self_.interface.set_text_color(arg_for_state, arg_color)
+    }
+    extern "C" fn set_enabled_text_colors<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+        color: u32,
+    ) {
+        let (arg_self_, arg_color) = (self_, color);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_color = arg_color.as_raw();
+        arg_self_.interface.set_enabled_text_colors(arg_color)
+    }
+    extern "C" fn set_font_list<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+        font_list: *const _cef_string_utf16_t,
+    ) {
+        let (arg_self_, arg_font_list) = (self_, font_list);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_font_list = WrapParamRef::<CefStringUtf16>::from(arg_font_list);
+        let arg_font_list = arg_font_list.as_ref();
+        arg_self_.interface.set_font_list(arg_font_list)
+    }
+    extern "C" fn set_horizontal_alignment<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+        alignment: cef_horizontal_alignment_t,
+    ) {
+        let (arg_self_, arg_alignment) = (self_, alignment);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_alignment = arg_alignment.as_raw();
+        arg_self_.interface.set_horizontal_alignment(arg_alignment)
+    }
+    extern "C" fn set_minimum_size<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+        size: *const _cef_size_t,
+    ) {
+        let (arg_self_, arg_size) = (self_, size);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_size = WrapParamRef::<Size>::from(arg_size);
+        let arg_size = arg_size.as_ref();
+        arg_self_.interface.set_minimum_size(arg_size)
+    }
+    extern "C" fn set_maximum_size<I: ImplLabelButton>(
+        self_: *mut _cef_label_button_t,
+        size: *const _cef_size_t,
+    ) {
+        let (arg_self_, arg_size) = (self_, size);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_size = WrapParamRef::<Size>::from(arg_size);
+        let arg_size = arg_size.as_ref();
+        arg_self_.interface.set_maximum_size(arg_size)
+    }
+}
+#[doc = "See [_cef_label_button_t] for more documentation."]
+#[derive(Clone)]
+pub struct LabelButton(RefGuard<_cef_label_button_t>);
+impl ImplLabelButton for LabelButton {
+    fn as_menu_button(&self) -> MenuButton {
+        unsafe {
+            self.0
+                .as_menu_button
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_text(&self, text: &CefStringUtf16) {
+        unsafe {
+            self.0
+                .set_text
+                .map(|f| {
+                    let arg_text = text;
+                    let arg_self_ = self.as_raw();
+                    let arg_text = arg_text.as_raw();
+                    let result = f(arg_self_, arg_text);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_text(&self) -> CefStringUtf16 {
+        unsafe {
+            self.0
+                .get_text
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_image(&self, button_state: ButtonState, image: &mut Image) {
+        unsafe {
+            self.0
+                .set_image
+                .map(|f| {
+                    let (arg_button_state, arg_image) = (button_state, image);
+                    let arg_self_ = self.as_raw();
+                    let arg_button_state = arg_button_state.as_raw();
+                    let arg_image = arg_image.as_raw();
+                    let result = f(arg_self_, arg_button_state, arg_image);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_image(&self, button_state: ButtonState) -> Image {
+        unsafe {
+            self.0
+                .get_image
+                .map(|f| {
+                    let arg_button_state = button_state;
+                    let arg_self_ = self.as_raw();
+                    let arg_button_state = arg_button_state.as_raw();
+                    let result = f(arg_self_, arg_button_state);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_text_color(&self, for_state: ButtonState, color: u32) {
+        unsafe {
+            self.0
+                .set_text_color
+                .map(|f| {
+                    let (arg_for_state, arg_color) = (for_state, color);
+                    let arg_self_ = self.as_raw();
+                    let arg_for_state = arg_for_state.as_raw();
+                    let arg_color = arg_color;
+                    let result = f(arg_self_, arg_for_state, arg_color);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_enabled_text_colors(&self, color: u32) {
+        unsafe {
+            self.0
+                .set_enabled_text_colors
+                .map(|f| {
+                    let arg_color = color;
+                    let arg_self_ = self.as_raw();
+                    let arg_color = arg_color;
+                    let result = f(arg_self_, arg_color);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_font_list(&self, font_list: &CefStringUtf16) {
+        unsafe {
+            self.0
+                .set_font_list
+                .map(|f| {
+                    let arg_font_list = font_list;
+                    let arg_self_ = self.as_raw();
+                    let arg_font_list = arg_font_list.as_raw();
+                    let result = f(arg_self_, arg_font_list);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_horizontal_alignment(&self, alignment: HorizontalAlignment) {
+        unsafe {
+            self.0
+                .set_horizontal_alignment
+                .map(|f| {
+                    let arg_alignment = alignment;
+                    let arg_self_ = self.as_raw();
+                    let arg_alignment = arg_alignment.as_raw();
+                    let result = f(arg_self_, arg_alignment);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_minimum_size(&self, size: &Size) {
+        unsafe {
+            self.0
+                .set_minimum_size
+                .map(|f| {
+                    let arg_size = size;
+                    let arg_self_ = self.as_raw();
+                    let arg_size = arg_size.as_raw();
+                    let result = f(arg_self_, arg_size);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_maximum_size(&self, size: &Size) {
+        unsafe {
+            self.0
+                .set_maximum_size
+                .map(|f| {
+                    let arg_size = size;
+                    let arg_self_ = self.as_raw();
+                    let arg_size = arg_size.as_raw();
+                    let result = f(arg_self_, arg_size);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_label_button_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for LabelButton {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_label_button_t> for &LabelButton {
+    fn as_raw(self) -> *mut _cef_label_button_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_label_button_t> for &mut LabelButton {
+    fn as_raw(self) -> *mut _cef_label_button_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<LabelButton> for *mut _cef_label_button_t {
+    fn as_wrapper(self) -> LabelButton {
+        LabelButton(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_label_button_t> for LabelButton {
+    fn into(self) -> *mut _cef_label_button_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for LabelButton {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplMenuButtonPressedLock: Sized {
+    fn into_raw(self) -> *mut _cef_menu_button_pressed_lock_t {
+        let mut object: _cef_menu_button_pressed_lock_t = unsafe { std::mem::zeroed() };
+        impl_cef_menu_button_pressed_lock_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_menu_button_pressed_lock_t {
+    use super::*;
+    pub fn init_methods<I: ImplMenuButtonPressedLock>(
+        object: &mut _cef_menu_button_pressed_lock_t,
+    ) {
+    }
+}
+#[doc = "See [_cef_menu_button_pressed_lock_t] for more documentation."]
+#[derive(Clone)]
+pub struct MenuButtonPressedLock(RefGuard<_cef_menu_button_pressed_lock_t>);
+impl ImplMenuButtonPressedLock for MenuButtonPressedLock {}
+impl Rc for _cef_menu_button_pressed_lock_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for MenuButtonPressedLock {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_menu_button_pressed_lock_t> for &MenuButtonPressedLock {
+    fn as_raw(self) -> *mut _cef_menu_button_pressed_lock_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_menu_button_pressed_lock_t> for &mut MenuButtonPressedLock {
+    fn as_raw(self) -> *mut _cef_menu_button_pressed_lock_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<MenuButtonPressedLock> for *mut _cef_menu_button_pressed_lock_t {
+    fn as_wrapper(self) -> MenuButtonPressedLock {
+        MenuButtonPressedLock(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_menu_button_pressed_lock_t> for MenuButtonPressedLock {
+    fn into(self) -> *mut _cef_menu_button_pressed_lock_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for MenuButtonPressedLock {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplMenuButtonDelegate: ImplButtonDelegate {
+    fn on_menu_button_pressed(
+        &self,
+        menu_button: &mut MenuButton,
+        screen_point: &Point,
+        button_pressed_lock: &mut MenuButtonPressedLock,
+    ) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_menu_button_delegate_t {
+        let mut object: _cef_menu_button_delegate_t = unsafe { std::mem::zeroed() };
+        impl_cef_view_delegate_t::init_methods::<Self>(&mut object.base.base);
+        impl_cef_button_delegate_t::init_methods::<Self>(&mut object.base);
+        impl_cef_menu_button_delegate_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_menu_button_delegate_t {
+    use super::*;
+    pub fn init_methods<I: ImplMenuButtonDelegate>(object: &mut _cef_menu_button_delegate_t) {
+        object.on_menu_button_pressed = Some(on_menu_button_pressed::<I>);
+    }
+    extern "C" fn on_menu_button_pressed<I: ImplMenuButtonDelegate>(
+        self_: *mut _cef_menu_button_delegate_t,
+        menu_button: *mut _cef_menu_button_t,
+        screen_point: *const _cef_point_t,
+        button_pressed_lock: *mut _cef_menu_button_pressed_lock_t,
+    ) {
+        let (arg_self_, arg_menu_button, arg_screen_point, arg_button_pressed_lock) =
+            (self_, menu_button, screen_point, button_pressed_lock);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_menu_button =
+            &mut MenuButton(unsafe { RefGuard::from_raw_add_ref(arg_menu_button) });
+        let arg_screen_point = WrapParamRef::<Point>::from(arg_screen_point);
+        let arg_screen_point = arg_screen_point.as_ref();
+        let arg_button_pressed_lock = &mut MenuButtonPressedLock(unsafe {
+            RefGuard::from_raw_add_ref(arg_button_pressed_lock)
+        });
+        arg_self_.interface.on_menu_button_pressed(
+            arg_menu_button,
+            arg_screen_point,
+            arg_button_pressed_lock,
+        )
+    }
+}
+#[doc = "See [_cef_menu_button_delegate_t] for more documentation."]
+#[derive(Clone)]
+pub struct MenuButtonDelegate(RefGuard<_cef_menu_button_delegate_t>);
+impl ImplMenuButtonDelegate for MenuButtonDelegate {
+    fn on_menu_button_pressed(
+        &self,
+        menu_button: &mut MenuButton,
+        screen_point: &Point,
+        button_pressed_lock: &mut MenuButtonPressedLock,
+    ) {
+        unsafe {
+            self.0
+                .on_menu_button_pressed
+                .map(|f| {
+                    let (arg_menu_button, arg_screen_point, arg_button_pressed_lock) =
+                        (menu_button, screen_point, button_pressed_lock);
+                    let arg_self_ = self.as_raw();
+                    let arg_menu_button = arg_menu_button.as_raw();
+                    let arg_screen_point = arg_screen_point.as_raw();
+                    let arg_button_pressed_lock = arg_button_pressed_lock.as_raw();
+                    let result = f(
+                        arg_self_,
+                        arg_menu_button,
+                        arg_screen_point,
+                        arg_button_pressed_lock,
+                    );
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_menu_button_delegate_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for MenuButtonDelegate {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_menu_button_delegate_t> for &MenuButtonDelegate {
+    fn as_raw(self) -> *mut _cef_menu_button_delegate_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_menu_button_delegate_t> for &mut MenuButtonDelegate {
+    fn as_raw(self) -> *mut _cef_menu_button_delegate_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<MenuButtonDelegate> for *mut _cef_menu_button_delegate_t {
+    fn as_wrapper(self) -> MenuButtonDelegate {
+        MenuButtonDelegate(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_menu_button_delegate_t> for MenuButtonDelegate {
+    fn into(self) -> *mut _cef_menu_button_delegate_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for MenuButtonDelegate {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplMenuButton: ImplLabelButton {
+    fn show_menu(
+        &self,
+        menu_model: &mut MenuModel,
+        screen_point: &Point,
+        anchor_position: MenuAnchorPosition,
+    ) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn trigger_menu(&self) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_menu_button_t {
+        let mut object: _cef_menu_button_t = unsafe { std::mem::zeroed() };
+        impl_cef_view_t::init_methods::<Self>(&mut object.base.base.base);
+        impl_cef_button_t::init_methods::<Self>(&mut object.base.base);
+        impl_cef_label_button_t::init_methods::<Self>(&mut object.base);
+        impl_cef_menu_button_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_menu_button_t {
+    use super::*;
+    pub fn init_methods<I: ImplMenuButton>(object: &mut _cef_menu_button_t) {
+        object.show_menu = Some(show_menu::<I>);
+        object.trigger_menu = Some(trigger_menu::<I>);
+    }
+    extern "C" fn show_menu<I: ImplMenuButton>(
+        self_: *mut _cef_menu_button_t,
+        menu_model: *mut _cef_menu_model_t,
+        screen_point: *const _cef_point_t,
+        anchor_position: cef_menu_anchor_position_t,
+    ) {
+        let (arg_self_, arg_menu_model, arg_screen_point, arg_anchor_position) =
+            (self_, menu_model, screen_point, anchor_position);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_menu_model = &mut MenuModel(unsafe { RefGuard::from_raw_add_ref(arg_menu_model) });
+        let arg_screen_point = WrapParamRef::<Point>::from(arg_screen_point);
+        let arg_screen_point = arg_screen_point.as_ref();
+        let arg_anchor_position = arg_anchor_position.as_raw();
+        arg_self_
+            .interface
+            .show_menu(arg_menu_model, arg_screen_point, arg_anchor_position)
+    }
+    extern "C" fn trigger_menu<I: ImplMenuButton>(self_: *mut _cef_menu_button_t) {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.trigger_menu()
+    }
+}
+#[doc = "See [_cef_menu_button_t] for more documentation."]
+#[derive(Clone)]
+pub struct MenuButton(RefGuard<_cef_menu_button_t>);
+impl ImplMenuButton for MenuButton {
+    fn show_menu(
+        &self,
+        menu_model: &mut MenuModel,
+        screen_point: &Point,
+        anchor_position: MenuAnchorPosition,
+    ) {
+        unsafe {
+            self.0
+                .show_menu
+                .map(|f| {
+                    let (arg_menu_model, arg_screen_point, arg_anchor_position) =
+                        (menu_model, screen_point, anchor_position);
+                    let arg_self_ = self.as_raw();
+                    let arg_menu_model = arg_menu_model.as_raw();
+                    let arg_screen_point = arg_screen_point.as_raw();
+                    let arg_anchor_position = arg_anchor_position.as_raw();
+                    let result = f(
+                        arg_self_,
+                        arg_menu_model,
+                        arg_screen_point,
+                        arg_anchor_position,
+                    );
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn trigger_menu(&self) {
+        unsafe {
+            self.0
+                .trigger_menu
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_menu_button_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for MenuButton {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_menu_button_t> for &MenuButton {
+    fn as_raw(self) -> *mut _cef_menu_button_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_menu_button_t> for &mut MenuButton {
+    fn as_raw(self) -> *mut _cef_menu_button_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<MenuButton> for *mut _cef_menu_button_t {
+    fn as_wrapper(self) -> MenuButton {
+        MenuButton(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_menu_button_t> for MenuButton {
+    fn into(self) -> *mut _cef_menu_button_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for MenuButton {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplTextfieldDelegate: ImplViewDelegate {
+    fn on_key_event(&self, textfield: &mut Textfield, event: &KeyEvent) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn on_after_user_action(&self, textfield: &mut Textfield) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_textfield_delegate_t {
+        let mut object: _cef_textfield_delegate_t = unsafe { std::mem::zeroed() };
+        impl_cef_view_delegate_t::init_methods::<Self>(&mut object.base);
+        impl_cef_textfield_delegate_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_textfield_delegate_t {
+    use super::*;
+    pub fn init_methods<I: ImplTextfieldDelegate>(object: &mut _cef_textfield_delegate_t) {
+        object.on_key_event = Some(on_key_event::<I>);
+        object.on_after_user_action = Some(on_after_user_action::<I>);
+    }
+    extern "C" fn on_key_event<I: ImplTextfieldDelegate>(
+        self_: *mut _cef_textfield_delegate_t,
+        textfield: *mut _cef_textfield_t,
+        event: *const _cef_key_event_t,
+    ) -> ::std::os::raw::c_int {
+        let (arg_self_, arg_textfield, arg_event) = (self_, textfield, event);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_textfield = &mut Textfield(unsafe { RefGuard::from_raw_add_ref(arg_textfield) });
+        let arg_event = WrapParamRef::<KeyEvent>::from(arg_event);
+        let arg_event = arg_event.as_ref();
+        arg_self_
+            .interface
+            .on_key_event(arg_textfield, arg_event)
+            .into()
+    }
+    extern "C" fn on_after_user_action<I: ImplTextfieldDelegate>(
+        self_: *mut _cef_textfield_delegate_t,
+        textfield: *mut _cef_textfield_t,
+    ) {
+        let (arg_self_, arg_textfield) = (self_, textfield);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_textfield = &mut Textfield(unsafe { RefGuard::from_raw_add_ref(arg_textfield) });
+        arg_self_.interface.on_after_user_action(arg_textfield)
+    }
+}
+#[doc = "See [_cef_textfield_delegate_t] for more documentation."]
+#[derive(Clone)]
+pub struct TextfieldDelegate(RefGuard<_cef_textfield_delegate_t>);
+impl ImplTextfieldDelegate for TextfieldDelegate {
+    fn on_key_event(&self, textfield: &mut Textfield, event: &KeyEvent) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .on_key_event
+                .map(|f| {
+                    let (arg_textfield, arg_event) = (textfield, event);
+                    let arg_self_ = self.as_raw();
+                    let arg_textfield = arg_textfield.as_raw();
+                    let arg_event = arg_event.as_raw();
+                    let result = f(arg_self_, arg_textfield, arg_event);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn on_after_user_action(&self, textfield: &mut Textfield) {
+        unsafe {
+            self.0
+                .on_after_user_action
+                .map(|f| {
+                    let arg_textfield = textfield;
+                    let arg_self_ = self.as_raw();
+                    let arg_textfield = arg_textfield.as_raw();
+                    let result = f(arg_self_, arg_textfield);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_textfield_delegate_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for TextfieldDelegate {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_textfield_delegate_t> for &TextfieldDelegate {
+    fn as_raw(self) -> *mut _cef_textfield_delegate_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_textfield_delegate_t> for &mut TextfieldDelegate {
+    fn as_raw(self) -> *mut _cef_textfield_delegate_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<TextfieldDelegate> for *mut _cef_textfield_delegate_t {
+    fn as_wrapper(self) -> TextfieldDelegate {
+        TextfieldDelegate(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_textfield_delegate_t> for TextfieldDelegate {
+    fn into(self) -> *mut _cef_textfield_delegate_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for TextfieldDelegate {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplTextfield: ImplView {
+    fn set_password_input(&self, password_input: ::std::os::raw::c_int) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn is_password_input(&self) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_read_only(&self, read_only: ::std::os::raw::c_int) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn is_read_only(&self) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_text(&self) -> CefStringUtf16 {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_text(&self, text: &CefStringUtf16) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn append_text(&self, text: &CefStringUtf16) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn insert_or_replace_text(&self, text: &CefStringUtf16) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn has_selection(&self) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_selected_text(&self) -> CefStringUtf16 {
+        unsafe { std::mem::zeroed() }
+    }
+    fn select_all(&self, reversed: ::std::os::raw::c_int) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn clear_selection(&self) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_selected_range(&self) -> Range {
+        unsafe { std::mem::zeroed() }
+    }
+    fn select_range(&self, range: &Range) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_cursor_position(&self) -> usize {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_text_color(&self, color: u32) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_text_color(&self) -> cef_color_t {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_selection_text_color(&self, color: u32) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_selection_text_color(&self) -> cef_color_t {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_selection_background_color(&self, color: u32) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_selection_background_color(&self) -> cef_color_t {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_font_list(&self, font_list: &CefStringUtf16) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn apply_text_color(&self, color: u32, range: &Range) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn apply_text_style(&self, style: TextStyle, add: ::std::os::raw::c_int, range: &Range) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn is_command_enabled(&self, command_id: TextFieldCommands) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn execute_command(&self, command_id: TextFieldCommands) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn clear_edit_history(&self) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_placeholder_text(&self, text: &CefStringUtf16) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_placeholder_text(&self) -> CefStringUtf16 {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_placeholder_text_color(&self, color: u32) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn set_accessible_name(&self, name: &CefStringUtf16) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_textfield_t {
+        let mut object: _cef_textfield_t = unsafe { std::mem::zeroed() };
+        impl_cef_view_t::init_methods::<Self>(&mut object.base);
+        impl_cef_textfield_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_textfield_t {
+    use super::*;
+    pub fn init_methods<I: ImplTextfield>(object: &mut _cef_textfield_t) {
+        object.set_password_input = Some(set_password_input::<I>);
+        object.is_password_input = Some(is_password_input::<I>);
+        object.set_read_only = Some(set_read_only::<I>);
+        object.is_read_only = Some(is_read_only::<I>);
+        object.get_text = Some(get_text::<I>);
+        object.set_text = Some(set_text::<I>);
+        object.append_text = Some(append_text::<I>);
+        object.insert_or_replace_text = Some(insert_or_replace_text::<I>);
+        object.has_selection = Some(has_selection::<I>);
+        object.get_selected_text = Some(get_selected_text::<I>);
+        object.select_all = Some(select_all::<I>);
+        object.clear_selection = Some(clear_selection::<I>);
+        object.get_selected_range = Some(get_selected_range::<I>);
+        object.select_range = Some(select_range::<I>);
+        object.get_cursor_position = Some(get_cursor_position::<I>);
+        object.set_text_color = Some(set_text_color::<I>);
+        object.get_text_color = Some(get_text_color::<I>);
+        object.set_selection_text_color = Some(set_selection_text_color::<I>);
+        object.get_selection_text_color = Some(get_selection_text_color::<I>);
+        object.set_selection_background_color = Some(set_selection_background_color::<I>);
+        object.get_selection_background_color = Some(get_selection_background_color::<I>);
+        object.set_font_list = Some(set_font_list::<I>);
+        object.apply_text_color = Some(apply_text_color::<I>);
+        object.apply_text_style = Some(apply_text_style::<I>);
+        object.is_command_enabled = Some(is_command_enabled::<I>);
+        object.execute_command = Some(execute_command::<I>);
+        object.clear_edit_history = Some(clear_edit_history::<I>);
+        object.set_placeholder_text = Some(set_placeholder_text::<I>);
+        object.get_placeholder_text = Some(get_placeholder_text::<I>);
+        object.set_placeholder_text_color = Some(set_placeholder_text_color::<I>);
+        object.set_accessible_name = Some(set_accessible_name::<I>);
+    }
+    extern "C" fn set_password_input<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        password_input: ::std::os::raw::c_int,
+    ) {
+        let (arg_self_, arg_password_input) = (self_, password_input);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_password_input = arg_password_input.as_raw();
+        arg_self_.interface.set_password_input(arg_password_input)
+    }
+    extern "C" fn is_password_input<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+    ) -> ::std::os::raw::c_int {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.is_password_input().into()
+    }
+    extern "C" fn set_read_only<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        read_only: ::std::os::raw::c_int,
+    ) {
+        let (arg_self_, arg_read_only) = (self_, read_only);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_read_only = arg_read_only.as_raw();
+        arg_self_.interface.set_read_only(arg_read_only)
+    }
+    extern "C" fn is_read_only<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+    ) -> ::std::os::raw::c_int {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.is_read_only().into()
+    }
+    extern "C" fn get_text<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+    ) -> *mut _cef_string_utf16_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_text().into()
+    }
+    extern "C" fn set_text<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        text: *const _cef_string_utf16_t,
+    ) {
+        let (arg_self_, arg_text) = (self_, text);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_text = WrapParamRef::<CefStringUtf16>::from(arg_text);
+        let arg_text = arg_text.as_ref();
+        arg_self_.interface.set_text(arg_text)
+    }
+    extern "C" fn append_text<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        text: *const _cef_string_utf16_t,
+    ) {
+        let (arg_self_, arg_text) = (self_, text);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_text = WrapParamRef::<CefStringUtf16>::from(arg_text);
+        let arg_text = arg_text.as_ref();
+        arg_self_.interface.append_text(arg_text)
+    }
+    extern "C" fn insert_or_replace_text<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        text: *const _cef_string_utf16_t,
+    ) {
+        let (arg_self_, arg_text) = (self_, text);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_text = WrapParamRef::<CefStringUtf16>::from(arg_text);
+        let arg_text = arg_text.as_ref();
+        arg_self_.interface.insert_or_replace_text(arg_text)
+    }
+    extern "C" fn has_selection<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+    ) -> ::std::os::raw::c_int {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.has_selection().into()
+    }
+    extern "C" fn get_selected_text<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+    ) -> *mut _cef_string_utf16_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_selected_text().into()
+    }
+    extern "C" fn select_all<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        reversed: ::std::os::raw::c_int,
+    ) {
+        let (arg_self_, arg_reversed) = (self_, reversed);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_reversed = arg_reversed.as_raw();
+        arg_self_.interface.select_all(arg_reversed)
+    }
+    extern "C" fn clear_selection<I: ImplTextfield>(self_: *mut _cef_textfield_t) {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.clear_selection()
+    }
+    extern "C" fn get_selected_range<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+    ) -> _cef_range_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_selected_range().into()
+    }
+    extern "C" fn select_range<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        range: *const _cef_range_t,
+    ) {
+        let (arg_self_, arg_range) = (self_, range);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_range = WrapParamRef::<Range>::from(arg_range);
+        let arg_range = arg_range.as_ref();
+        arg_self_.interface.select_range(arg_range)
+    }
+    extern "C" fn get_cursor_position<I: ImplTextfield>(self_: *mut _cef_textfield_t) -> usize {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_cursor_position().into()
+    }
+    extern "C" fn set_text_color<I: ImplTextfield>(self_: *mut _cef_textfield_t, color: u32) {
+        let (arg_self_, arg_color) = (self_, color);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_color = arg_color.as_raw();
+        arg_self_.interface.set_text_color(arg_color)
+    }
+    extern "C" fn get_text_color<I: ImplTextfield>(self_: *mut _cef_textfield_t) -> u32 {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_text_color().into()
+    }
+    extern "C" fn set_selection_text_color<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        color: u32,
+    ) {
+        let (arg_self_, arg_color) = (self_, color);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_color = arg_color.as_raw();
+        arg_self_.interface.set_selection_text_color(arg_color)
+    }
+    extern "C" fn get_selection_text_color<I: ImplTextfield>(self_: *mut _cef_textfield_t) -> u32 {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_selection_text_color().into()
+    }
+    extern "C" fn set_selection_background_color<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        color: u32,
+    ) {
+        let (arg_self_, arg_color) = (self_, color);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_color = arg_color.as_raw();
+        arg_self_
+            .interface
+            .set_selection_background_color(arg_color)
+    }
+    extern "C" fn get_selection_background_color<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+    ) -> u32 {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_selection_background_color().into()
+    }
+    extern "C" fn set_font_list<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        font_list: *const _cef_string_utf16_t,
+    ) {
+        let (arg_self_, arg_font_list) = (self_, font_list);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_font_list = WrapParamRef::<CefStringUtf16>::from(arg_font_list);
+        let arg_font_list = arg_font_list.as_ref();
+        arg_self_.interface.set_font_list(arg_font_list)
+    }
+    extern "C" fn apply_text_color<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        color: u32,
+        range: *const _cef_range_t,
+    ) {
+        let (arg_self_, arg_color, arg_range) = (self_, color, range);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_color = arg_color.as_raw();
+        let arg_range = WrapParamRef::<Range>::from(arg_range);
+        let arg_range = arg_range.as_ref();
+        arg_self_.interface.apply_text_color(arg_color, arg_range)
+    }
+    extern "C" fn apply_text_style<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        style: cef_text_style_t,
+        add: ::std::os::raw::c_int,
+        range: *const _cef_range_t,
+    ) {
+        let (arg_self_, arg_style, arg_add, arg_range) = (self_, style, add, range);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_style = arg_style.as_raw();
+        let arg_add = arg_add.as_raw();
+        let arg_range = WrapParamRef::<Range>::from(arg_range);
+        let arg_range = arg_range.as_ref();
+        arg_self_
+            .interface
+            .apply_text_style(arg_style, arg_add, arg_range)
+    }
+    extern "C" fn is_command_enabled<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        command_id: cef_text_field_commands_t,
+    ) -> ::std::os::raw::c_int {
+        let (arg_self_, arg_command_id) = (self_, command_id);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_command_id = arg_command_id.as_raw();
+        arg_self_
+            .interface
+            .is_command_enabled(arg_command_id)
+            .into()
+    }
+    extern "C" fn execute_command<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        command_id: cef_text_field_commands_t,
+    ) {
+        let (arg_self_, arg_command_id) = (self_, command_id);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_command_id = arg_command_id.as_raw();
+        arg_self_.interface.execute_command(arg_command_id)
+    }
+    extern "C" fn clear_edit_history<I: ImplTextfield>(self_: *mut _cef_textfield_t) {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.clear_edit_history()
+    }
+    extern "C" fn set_placeholder_text<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        text: *const _cef_string_utf16_t,
+    ) {
+        let (arg_self_, arg_text) = (self_, text);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_text = WrapParamRef::<CefStringUtf16>::from(arg_text);
+        let arg_text = arg_text.as_ref();
+        arg_self_.interface.set_placeholder_text(arg_text)
+    }
+    extern "C" fn get_placeholder_text<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+    ) -> *mut _cef_string_utf16_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_placeholder_text().into()
+    }
+    extern "C" fn set_placeholder_text_color<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        color: u32,
+    ) {
+        let (arg_self_, arg_color) = (self_, color);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_color = arg_color.as_raw();
+        arg_self_.interface.set_placeholder_text_color(arg_color)
+    }
+    extern "C" fn set_accessible_name<I: ImplTextfield>(
+        self_: *mut _cef_textfield_t,
+        name: *const _cef_string_utf16_t,
+    ) {
+        let (arg_self_, arg_name) = (self_, name);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_name = WrapParamRef::<CefStringUtf16>::from(arg_name);
+        let arg_name = arg_name.as_ref();
+        arg_self_.interface.set_accessible_name(arg_name)
+    }
+}
+#[doc = "See [_cef_textfield_t] for more documentation."]
+#[derive(Clone)]
+pub struct Textfield(RefGuard<_cef_textfield_t>);
+impl ImplTextfield for Textfield {
+    fn set_password_input(&self, password_input: ::std::os::raw::c_int) {
+        unsafe {
+            self.0
+                .set_password_input
+                .map(|f| {
+                    let arg_password_input = password_input;
+                    let arg_self_ = self.as_raw();
+                    let arg_password_input = arg_password_input;
+                    let result = f(arg_self_, arg_password_input);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn is_password_input(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .is_password_input
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_read_only(&self, read_only: ::std::os::raw::c_int) {
+        unsafe {
+            self.0
+                .set_read_only
+                .map(|f| {
+                    let arg_read_only = read_only;
+                    let arg_self_ = self.as_raw();
+                    let arg_read_only = arg_read_only;
+                    let result = f(arg_self_, arg_read_only);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn is_read_only(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .is_read_only
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_text(&self) -> CefStringUtf16 {
+        unsafe {
+            self.0
+                .get_text
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_text(&self, text: &CefStringUtf16) {
+        unsafe {
+            self.0
+                .set_text
+                .map(|f| {
+                    let arg_text = text;
+                    let arg_self_ = self.as_raw();
+                    let arg_text = arg_text.as_raw();
+                    let result = f(arg_self_, arg_text);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn append_text(&self, text: &CefStringUtf16) {
+        unsafe {
+            self.0
+                .append_text
+                .map(|f| {
+                    let arg_text = text;
+                    let arg_self_ = self.as_raw();
+                    let arg_text = arg_text.as_raw();
+                    let result = f(arg_self_, arg_text);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn insert_or_replace_text(&self, text: &CefStringUtf16) {
+        unsafe {
+            self.0
+                .insert_or_replace_text
+                .map(|f| {
+                    let arg_text = text;
+                    let arg_self_ = self.as_raw();
+                    let arg_text = arg_text.as_raw();
+                    let result = f(arg_self_, arg_text);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn has_selection(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .has_selection
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_selected_text(&self) -> CefStringUtf16 {
+        unsafe {
+            self.0
+                .get_selected_text
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn select_all(&self, reversed: ::std::os::raw::c_int) {
+        unsafe {
+            self.0
+                .select_all
+                .map(|f| {
+                    let arg_reversed = reversed;
+                    let arg_self_ = self.as_raw();
+                    let arg_reversed = arg_reversed;
+                    let result = f(arg_self_, arg_reversed);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn clear_selection(&self) {
+        unsafe {
+            self.0
+                .clear_selection
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_selected_range(&self) -> Range {
+        unsafe {
+            self.0
+                .get_selected_range
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn select_range(&self, range: &Range) {
+        unsafe {
+            self.0
+                .select_range
+                .map(|f| {
+                    let arg_range = range;
+                    let arg_self_ = self.as_raw();
+                    let arg_range = arg_range.as_raw();
+                    let result = f(arg_self_, arg_range);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_cursor_position(&self) -> usize {
+        unsafe {
+            self.0
+                .get_cursor_position
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_text_color(&self, color: u32) {
+        unsafe {
+            self.0
+                .set_text_color
+                .map(|f| {
+                    let arg_color = color;
+                    let arg_self_ = self.as_raw();
+                    let arg_color = arg_color;
+                    let result = f(arg_self_, arg_color);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_text_color(&self) -> cef_color_t {
+        unsafe {
+            self.0
+                .get_text_color
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_selection_text_color(&self, color: u32) {
+        unsafe {
+            self.0
+                .set_selection_text_color
+                .map(|f| {
+                    let arg_color = color;
+                    let arg_self_ = self.as_raw();
+                    let arg_color = arg_color;
+                    let result = f(arg_self_, arg_color);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_selection_text_color(&self) -> cef_color_t {
+        unsafe {
+            self.0
+                .get_selection_text_color
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_selection_background_color(&self, color: u32) {
+        unsafe {
+            self.0
+                .set_selection_background_color
+                .map(|f| {
+                    let arg_color = color;
+                    let arg_self_ = self.as_raw();
+                    let arg_color = arg_color;
+                    let result = f(arg_self_, arg_color);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_selection_background_color(&self) -> cef_color_t {
+        unsafe {
+            self.0
+                .get_selection_background_color
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_font_list(&self, font_list: &CefStringUtf16) {
+        unsafe {
+            self.0
+                .set_font_list
+                .map(|f| {
+                    let arg_font_list = font_list;
+                    let arg_self_ = self.as_raw();
+                    let arg_font_list = arg_font_list.as_raw();
+                    let result = f(arg_self_, arg_font_list);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn apply_text_color(&self, color: u32, range: &Range) {
+        unsafe {
+            self.0
+                .apply_text_color
+                .map(|f| {
+                    let (arg_color, arg_range) = (color, range);
+                    let arg_self_ = self.as_raw();
+                    let arg_color = arg_color;
+                    let arg_range = arg_range.as_raw();
+                    let result = f(arg_self_, arg_color, arg_range);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn apply_text_style(&self, style: TextStyle, add: ::std::os::raw::c_int, range: &Range) {
+        unsafe {
+            self.0
+                .apply_text_style
+                .map(|f| {
+                    let (arg_style, arg_add, arg_range) = (style, add, range);
+                    let arg_self_ = self.as_raw();
+                    let arg_style = arg_style.as_raw();
+                    let arg_add = arg_add;
+                    let arg_range = arg_range.as_raw();
+                    let result = f(arg_self_, arg_style, arg_add, arg_range);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn is_command_enabled(&self, command_id: TextFieldCommands) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .is_command_enabled
+                .map(|f| {
+                    let arg_command_id = command_id;
+                    let arg_self_ = self.as_raw();
+                    let arg_command_id = arg_command_id.as_raw();
+                    let result = f(arg_self_, arg_command_id);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn execute_command(&self, command_id: TextFieldCommands) {
+        unsafe {
+            self.0
+                .execute_command
+                .map(|f| {
+                    let arg_command_id = command_id;
+                    let arg_self_ = self.as_raw();
+                    let arg_command_id = arg_command_id.as_raw();
+                    let result = f(arg_self_, arg_command_id);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn clear_edit_history(&self) {
+        unsafe {
+            self.0
+                .clear_edit_history
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_placeholder_text(&self, text: &CefStringUtf16) {
+        unsafe {
+            self.0
+                .set_placeholder_text
+                .map(|f| {
+                    let arg_text = text;
+                    let arg_self_ = self.as_raw();
+                    let arg_text = arg_text.as_raw();
+                    let result = f(arg_self_, arg_text);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_placeholder_text(&self) -> CefStringUtf16 {
+        unsafe {
+            self.0
+                .get_placeholder_text
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_placeholder_text_color(&self, color: u32) {
+        unsafe {
+            self.0
+                .set_placeholder_text_color
+                .map(|f| {
+                    let arg_color = color;
+                    let arg_self_ = self.as_raw();
+                    let arg_color = arg_color;
+                    let result = f(arg_self_, arg_color);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn set_accessible_name(&self, name: &CefStringUtf16) {
+        unsafe {
+            self.0
+                .set_accessible_name
+                .map(|f| {
+                    let arg_name = name;
+                    let arg_self_ = self.as_raw();
+                    let arg_name = arg_name.as_raw();
+                    let result = f(arg_self_, arg_name);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_textfield_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for Textfield {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_textfield_t> for &Textfield {
+    fn as_raw(self) -> *mut _cef_textfield_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_textfield_t> for &mut Textfield {
+    fn as_raw(self) -> *mut _cef_textfield_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<Textfield> for *mut _cef_textfield_t {
+    fn as_wrapper(self) -> Textfield {
+        Textfield(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_textfield_t> for Textfield {
+    fn into(self) -> *mut _cef_textfield_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for Textfield {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+pub trait ImplBrowserViewDelegate: ImplViewDelegate {
+    fn on_browser_created(&self, browser_view: &mut BrowserView, browser: &mut Browser) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn on_browser_destroyed(&self, browser_view: &mut BrowserView, browser: &mut Browser) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_delegate_for_popup_browser_view(
+        &self,
+        browser_view: &mut BrowserView,
+        settings: &BrowserSettings,
+        client: &mut Client,
+        is_devtools: ::std::os::raw::c_int,
+    ) -> BrowserViewDelegate {
+        unsafe { std::mem::zeroed() }
+    }
+    fn on_popup_browser_view_created(
+        &self,
+        browser_view: &mut BrowserView,
+        popup_browser_view: &mut BrowserView,
+        is_devtools: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_chrome_toolbar_type(&self, browser_view: &mut BrowserView) -> ChromeToolbarType {
+        unsafe { std::mem::zeroed() }
+    }
+    fn use_frameless_window_for_picture_in_picture(
+        &self,
+        browser_view: &mut BrowserView,
+    ) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn on_gesture_command(
+        &self,
+        browser_view: &mut BrowserView,
+        gesture_command: GestureCommand,
+    ) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_browser_runtime_style(&self) -> RuntimeStyle {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_browser_view_delegate_t {
+        let mut object: _cef_browser_view_delegate_t = unsafe { std::mem::zeroed() };
+        impl_cef_view_delegate_t::init_methods::<Self>(&mut object.base);
+        impl_cef_browser_view_delegate_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_browser_view_delegate_t {
+    use super::*;
+    pub fn init_methods<I: ImplBrowserViewDelegate>(object: &mut _cef_browser_view_delegate_t) {
+        object.on_browser_created = Some(on_browser_created::<I>);
+        object.on_browser_destroyed = Some(on_browser_destroyed::<I>);
+        object.get_delegate_for_popup_browser_view = Some(get_delegate_for_popup_browser_view::<I>);
+        object.on_popup_browser_view_created = Some(on_popup_browser_view_created::<I>);
+        object.get_chrome_toolbar_type = Some(get_chrome_toolbar_type::<I>);
+        object.use_frameless_window_for_picture_in_picture =
+            Some(use_frameless_window_for_picture_in_picture::<I>);
+        object.on_gesture_command = Some(on_gesture_command::<I>);
+        object.get_browser_runtime_style = Some(get_browser_runtime_style::<I>);
+    }
+    extern "C" fn on_browser_created<I: ImplBrowserViewDelegate>(
+        self_: *mut _cef_browser_view_delegate_t,
+        browser_view: *mut _cef_browser_view_t,
+        browser: *mut _cef_browser_t,
+    ) {
+        let (arg_self_, arg_browser_view, arg_browser) = (self_, browser_view, browser);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_browser_view =
+            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
+        let arg_browser = &mut Browser(unsafe { RefGuard::from_raw_add_ref(arg_browser) });
+        arg_self_
+            .interface
+            .on_browser_created(arg_browser_view, arg_browser)
+    }
+    extern "C" fn on_browser_destroyed<I: ImplBrowserViewDelegate>(
+        self_: *mut _cef_browser_view_delegate_t,
+        browser_view: *mut _cef_browser_view_t,
+        browser: *mut _cef_browser_t,
+    ) {
+        let (arg_self_, arg_browser_view, arg_browser) = (self_, browser_view, browser);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_browser_view =
+            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
+        let arg_browser = &mut Browser(unsafe { RefGuard::from_raw_add_ref(arg_browser) });
+        arg_self_
+            .interface
+            .on_browser_destroyed(arg_browser_view, arg_browser)
+    }
+    extern "C" fn get_delegate_for_popup_browser_view<I: ImplBrowserViewDelegate>(
+        self_: *mut _cef_browser_view_delegate_t,
+        browser_view: *mut _cef_browser_view_t,
+        settings: *const _cef_browser_settings_t,
+        client: *mut _cef_client_t,
+        is_devtools: ::std::os::raw::c_int,
+    ) -> *mut _cef_browser_view_delegate_t {
+        let (arg_self_, arg_browser_view, arg_settings, arg_client, arg_is_devtools) =
+            (self_, browser_view, settings, client, is_devtools);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_browser_view =
+            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
+        let arg_settings = WrapParamRef::<BrowserSettings>::from(arg_settings);
+        let arg_settings = arg_settings.as_ref();
+        let arg_client = &mut Client(unsafe { RefGuard::from_raw_add_ref(arg_client) });
+        let arg_is_devtools = arg_is_devtools.as_raw();
+        arg_self_
+            .interface
+            .get_delegate_for_popup_browser_view(
+                arg_browser_view,
+                arg_settings,
+                arg_client,
+                arg_is_devtools,
+            )
+            .into()
+    }
+    extern "C" fn on_popup_browser_view_created<I: ImplBrowserViewDelegate>(
+        self_: *mut _cef_browser_view_delegate_t,
+        browser_view: *mut _cef_browser_view_t,
+        popup_browser_view: *mut _cef_browser_view_t,
+        is_devtools: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        let (arg_self_, arg_browser_view, arg_popup_browser_view, arg_is_devtools) =
+            (self_, browser_view, popup_browser_view, is_devtools);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_browser_view =
+            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
+        let arg_popup_browser_view =
+            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_popup_browser_view) });
+        let arg_is_devtools = arg_is_devtools.as_raw();
+        arg_self_
+            .interface
+            .on_popup_browser_view_created(
+                arg_browser_view,
+                arg_popup_browser_view,
+                arg_is_devtools,
+            )
+            .into()
+    }
+    extern "C" fn get_chrome_toolbar_type<I: ImplBrowserViewDelegate>(
+        self_: *mut _cef_browser_view_delegate_t,
+        browser_view: *mut _cef_browser_view_t,
+    ) -> cef_chrome_toolbar_type_t {
+        let (arg_self_, arg_browser_view) = (self_, browser_view);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_browser_view =
+            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
+        arg_self_
+            .interface
+            .get_chrome_toolbar_type(arg_browser_view)
+            .into()
+    }
+    extern "C" fn use_frameless_window_for_picture_in_picture<I: ImplBrowserViewDelegate>(
+        self_: *mut _cef_browser_view_delegate_t,
+        browser_view: *mut _cef_browser_view_t,
+    ) -> ::std::os::raw::c_int {
+        let (arg_self_, arg_browser_view) = (self_, browser_view);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_browser_view =
+            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
+        arg_self_
+            .interface
+            .use_frameless_window_for_picture_in_picture(arg_browser_view)
+            .into()
+    }
+    extern "C" fn on_gesture_command<I: ImplBrowserViewDelegate>(
+        self_: *mut _cef_browser_view_delegate_t,
+        browser_view: *mut _cef_browser_view_t,
+        gesture_command: cef_gesture_command_t,
+    ) -> ::std::os::raw::c_int {
+        let (arg_self_, arg_browser_view, arg_gesture_command) =
+            (self_, browser_view, gesture_command);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_browser_view =
+            &mut BrowserView(unsafe { RefGuard::from_raw_add_ref(arg_browser_view) });
+        let arg_gesture_command = arg_gesture_command.as_raw();
+        arg_self_
+            .interface
+            .on_gesture_command(arg_browser_view, arg_gesture_command)
+            .into()
+    }
+    extern "C" fn get_browser_runtime_style<I: ImplBrowserViewDelegate>(
+        self_: *mut _cef_browser_view_delegate_t,
+    ) -> cef_runtime_style_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_browser_runtime_style().into()
+    }
+}
+#[doc = "See [_cef_browser_view_delegate_t] for more documentation."]
+#[derive(Clone)]
+pub struct BrowserViewDelegate(RefGuard<_cef_browser_view_delegate_t>);
+impl ImplBrowserViewDelegate for BrowserViewDelegate {
+    fn on_browser_created(&self, browser_view: &mut BrowserView, browser: &mut Browser) {
+        unsafe {
+            self.0
+                .on_browser_created
+                .map(|f| {
+                    let (arg_browser_view, arg_browser) = (browser_view, browser);
+                    let arg_self_ = self.as_raw();
+                    let arg_browser_view = arg_browser_view.as_raw();
+                    let arg_browser = arg_browser.as_raw();
+                    let result = f(arg_self_, arg_browser_view, arg_browser);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn on_browser_destroyed(&self, browser_view: &mut BrowserView, browser: &mut Browser) {
+        unsafe {
+            self.0
+                .on_browser_destroyed
+                .map(|f| {
+                    let (arg_browser_view, arg_browser) = (browser_view, browser);
+                    let arg_self_ = self.as_raw();
+                    let arg_browser_view = arg_browser_view.as_raw();
+                    let arg_browser = arg_browser.as_raw();
+                    let result = f(arg_self_, arg_browser_view, arg_browser);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_delegate_for_popup_browser_view(
+        &self,
+        browser_view: &mut BrowserView,
+        settings: &BrowserSettings,
+        client: &mut Client,
+        is_devtools: ::std::os::raw::c_int,
+    ) -> BrowserViewDelegate {
+        unsafe {
+            self.0
+                .get_delegate_for_popup_browser_view
+                .map(|f| {
+                    let (arg_browser_view, arg_settings, arg_client, arg_is_devtools) =
+                        (browser_view, settings, client, is_devtools);
+                    let arg_self_ = self.as_raw();
+                    let arg_browser_view = arg_browser_view.as_raw();
+                    let arg_settings = arg_settings.as_raw();
+                    let arg_client = arg_client.as_raw();
+                    let arg_is_devtools = arg_is_devtools;
+                    let result = f(
+                        arg_self_,
+                        arg_browser_view,
+                        arg_settings,
+                        arg_client,
+                        arg_is_devtools,
+                    );
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn on_popup_browser_view_created(
+        &self,
+        browser_view: &mut BrowserView,
+        popup_browser_view: &mut BrowserView,
+        is_devtools: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .on_popup_browser_view_created
+                .map(|f| {
+                    let (arg_browser_view, arg_popup_browser_view, arg_is_devtools) =
+                        (browser_view, popup_browser_view, is_devtools);
+                    let arg_self_ = self.as_raw();
+                    let arg_browser_view = arg_browser_view.as_raw();
+                    let arg_popup_browser_view = arg_popup_browser_view.as_raw();
+                    let arg_is_devtools = arg_is_devtools;
+                    let result = f(
+                        arg_self_,
+                        arg_browser_view,
+                        arg_popup_browser_view,
+                        arg_is_devtools,
+                    );
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_chrome_toolbar_type(&self, browser_view: &mut BrowserView) -> ChromeToolbarType {
+        unsafe {
+            self.0
+                .get_chrome_toolbar_type
+                .map(|f| {
+                    let arg_browser_view = browser_view;
+                    let arg_self_ = self.as_raw();
+                    let arg_browser_view = arg_browser_view.as_raw();
+                    let result = f(arg_self_, arg_browser_view);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn use_frameless_window_for_picture_in_picture(
+        &self,
+        browser_view: &mut BrowserView,
+    ) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .use_frameless_window_for_picture_in_picture
+                .map(|f| {
+                    let arg_browser_view = browser_view;
+                    let arg_self_ = self.as_raw();
+                    let arg_browser_view = arg_browser_view.as_raw();
+                    let result = f(arg_self_, arg_browser_view);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn on_gesture_command(
+        &self,
+        browser_view: &mut BrowserView,
+        gesture_command: GestureCommand,
+    ) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .on_gesture_command
+                .map(|f| {
+                    let (arg_browser_view, arg_gesture_command) = (browser_view, gesture_command);
+                    let arg_self_ = self.as_raw();
+                    let arg_browser_view = arg_browser_view.as_raw();
+                    let arg_gesture_command = arg_gesture_command.as_raw();
+                    let result = f(arg_self_, arg_browser_view, arg_gesture_command);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_browser_runtime_style(&self) -> RuntimeStyle {
+        unsafe {
+            self.0
+                .get_browser_runtime_style
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_browser_view_delegate_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for BrowserViewDelegate {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_browser_view_delegate_t> for &BrowserViewDelegate {
+    fn as_raw(self) -> *mut _cef_browser_view_delegate_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_browser_view_delegate_t> for &mut BrowserViewDelegate {
+    fn as_raw(self) -> *mut _cef_browser_view_delegate_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<BrowserViewDelegate> for *mut _cef_browser_view_delegate_t {
+    fn as_wrapper(self) -> BrowserViewDelegate {
+        BrowserViewDelegate(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_browser_view_delegate_t> for BrowserViewDelegate {
+    fn into(self) -> *mut _cef_browser_view_delegate_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for BrowserViewDelegate {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
 pub trait ImplBrowserView: ImplView {
     fn get_browser(&self) -> Browser {
         unsafe { std::mem::zeroed() }
@@ -39268,6 +41745,224 @@ impl Default for BrowserView {
         unsafe { std::mem::zeroed() }
     }
 }
+pub trait ImplScrollView: ImplView {
+    fn set_content_view(&self, view: &mut View) {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_content_view(&self) -> View {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_visible_content_rect(&self) -> Rect {
+        unsafe { std::mem::zeroed() }
+    }
+    fn has_horizontal_scrollbar(&self) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_horizontal_scrollbar_height(&self) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn has_vertical_scrollbar(&self) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn get_vertical_scrollbar_width(&self) -> ::std::os::raw::c_int {
+        unsafe { std::mem::zeroed() }
+    }
+    fn into_raw(self) -> *mut _cef_scroll_view_t {
+        let mut object: _cef_scroll_view_t = unsafe { std::mem::zeroed() };
+        impl_cef_view_t::init_methods::<Self>(&mut object.base);
+        impl_cef_scroll_view_t::init_methods::<Self>(&mut object);
+        RcImpl::new(object, self) as *mut _
+    }
+}
+mod impl_cef_scroll_view_t {
+    use super::*;
+    pub fn init_methods<I: ImplScrollView>(object: &mut _cef_scroll_view_t) {
+        object.set_content_view = Some(set_content_view::<I>);
+        object.get_content_view = Some(get_content_view::<I>);
+        object.get_visible_content_rect = Some(get_visible_content_rect::<I>);
+        object.has_horizontal_scrollbar = Some(has_horizontal_scrollbar::<I>);
+        object.get_horizontal_scrollbar_height = Some(get_horizontal_scrollbar_height::<I>);
+        object.has_vertical_scrollbar = Some(has_vertical_scrollbar::<I>);
+        object.get_vertical_scrollbar_width = Some(get_vertical_scrollbar_width::<I>);
+    }
+    extern "C" fn set_content_view<I: ImplScrollView>(
+        self_: *mut _cef_scroll_view_t,
+        view: *mut _cef_view_t,
+    ) {
+        let (arg_self_, arg_view) = (self_, view);
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        let arg_view = &mut View(unsafe { RefGuard::from_raw_add_ref(arg_view) });
+        arg_self_.interface.set_content_view(arg_view)
+    }
+    extern "C" fn get_content_view<I: ImplScrollView>(
+        self_: *mut _cef_scroll_view_t,
+    ) -> *mut _cef_view_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_content_view().into()
+    }
+    extern "C" fn get_visible_content_rect<I: ImplScrollView>(
+        self_: *mut _cef_scroll_view_t,
+    ) -> _cef_rect_t {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_visible_content_rect().into()
+    }
+    extern "C" fn has_horizontal_scrollbar<I: ImplScrollView>(
+        self_: *mut _cef_scroll_view_t,
+    ) -> ::std::os::raw::c_int {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.has_horizontal_scrollbar().into()
+    }
+    extern "C" fn get_horizontal_scrollbar_height<I: ImplScrollView>(
+        self_: *mut _cef_scroll_view_t,
+    ) -> ::std::os::raw::c_int {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_horizontal_scrollbar_height().into()
+    }
+    extern "C" fn has_vertical_scrollbar<I: ImplScrollView>(
+        self_: *mut _cef_scroll_view_t,
+    ) -> ::std::os::raw::c_int {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.has_vertical_scrollbar().into()
+    }
+    extern "C" fn get_vertical_scrollbar_width<I: ImplScrollView>(
+        self_: *mut _cef_scroll_view_t,
+    ) -> ::std::os::raw::c_int {
+        let arg_self_ = self_;
+        let arg_self_: &RcImpl<_, I> = RcImpl::get(arg_self_);
+        arg_self_.interface.get_vertical_scrollbar_width().into()
+    }
+}
+#[doc = "See [_cef_scroll_view_t] for more documentation."]
+#[derive(Clone)]
+pub struct ScrollView(RefGuard<_cef_scroll_view_t>);
+impl ImplScrollView for ScrollView {
+    fn set_content_view(&self, view: &mut View) {
+        unsafe {
+            self.0
+                .set_content_view
+                .map(|f| {
+                    let arg_view = view;
+                    let arg_self_ = self.as_raw();
+                    let arg_view = arg_view.as_raw();
+                    let result = f(arg_self_, arg_view);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_content_view(&self) -> View {
+        unsafe {
+            self.0
+                .get_content_view
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_visible_content_rect(&self) -> Rect {
+        unsafe {
+            self.0
+                .get_visible_content_rect
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn has_horizontal_scrollbar(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .has_horizontal_scrollbar
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_horizontal_scrollbar_height(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .get_horizontal_scrollbar_height
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn has_vertical_scrollbar(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .has_vertical_scrollbar
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+    fn get_vertical_scrollbar_width(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            self.0
+                .get_vertical_scrollbar_width
+                .map(|f| {
+                    let arg_self_ = self.as_raw();
+                    let result = f(arg_self_);
+                    result.as_wrapper()
+                })
+                .unwrap_or_else(|| std::mem::zeroed())
+        }
+    }
+}
+impl Rc for _cef_scroll_view_t {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.base.as_base()
+    }
+}
+impl Rc for ScrollView {
+    fn as_base(&self) -> &_cef_base_ref_counted_t {
+        self.0.as_base()
+    }
+}
+impl ConvertParam<*mut _cef_scroll_view_t> for &ScrollView {
+    fn as_raw(self) -> *mut _cef_scroll_view_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertParam<*mut _cef_scroll_view_t> for &mut ScrollView {
+    fn as_raw(self) -> *mut _cef_scroll_view_t {
+        unsafe { (&self.0).as_raw() }
+    }
+}
+impl ConvertReturnValue<ScrollView> for *mut _cef_scroll_view_t {
+    fn as_wrapper(self) -> ScrollView {
+        ScrollView(unsafe { RefGuard::from_raw(self) })
+    }
+}
+impl Into<*mut _cef_scroll_view_t> for ScrollView {
+    fn into(self) -> *mut _cef_scroll_view_t {
+        unsafe { self.0.into_raw() }
+    }
+}
+impl Default for ScrollView {
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
 pub trait ImplDisplay: Sized {
     fn get_id(&self) -> i64 {
         unsafe { std::mem::zeroed() }
@@ -40049,120 +42744,6 @@ impl Default for PanelDelegate {
         unsafe { std::mem::zeroed() }
     }
 }
-#[doc = "See [_cef_box_layout_t] for more documentation."]
-#[repr(transparent)]
-pub struct BoxLayout(_cef_box_layout_t);
-impl From<_cef_box_layout_t> for BoxLayout {
-    fn from(value: _cef_box_layout_t) -> Self {
-        Self(value)
-    }
-}
-impl Into<*const _cef_box_layout_t> for &BoxLayout {
-    fn into(self) -> *const _cef_box_layout_t {
-        self.as_ref() as *const _cef_box_layout_t
-    }
-}
-impl Into<*mut _cef_box_layout_t> for &mut BoxLayout {
-    fn into(self) -> *mut _cef_box_layout_t {
-        self.as_mut() as *mut _cef_box_layout_t
-    }
-}
-impl Into<_cef_box_layout_t> for BoxLayout {
-    fn into(self) -> _cef_box_layout_t {
-        self.0
-    }
-}
-impl AsRef<_cef_box_layout_t> for BoxLayout {
-    fn as_ref(&self) -> &_cef_box_layout_t {
-        &self.0
-    }
-}
-impl AsMut<_cef_box_layout_t> for BoxLayout {
-    fn as_mut(&mut self) -> &mut _cef_box_layout_t {
-        &mut self.0
-    }
-}
-impl Default for BoxLayout {
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
-#[doc = "See [_cef_fill_layout_t] for more documentation."]
-#[repr(transparent)]
-pub struct FillLayout(_cef_fill_layout_t);
-impl From<_cef_fill_layout_t> for FillLayout {
-    fn from(value: _cef_fill_layout_t) -> Self {
-        Self(value)
-    }
-}
-impl Into<*const _cef_fill_layout_t> for &FillLayout {
-    fn into(self) -> *const _cef_fill_layout_t {
-        self.as_ref() as *const _cef_fill_layout_t
-    }
-}
-impl Into<*mut _cef_fill_layout_t> for &mut FillLayout {
-    fn into(self) -> *mut _cef_fill_layout_t {
-        self.as_mut() as *mut _cef_fill_layout_t
-    }
-}
-impl Into<_cef_fill_layout_t> for FillLayout {
-    fn into(self) -> _cef_fill_layout_t {
-        self.0
-    }
-}
-impl AsRef<_cef_fill_layout_t> for FillLayout {
-    fn as_ref(&self) -> &_cef_fill_layout_t {
-        &self.0
-    }
-}
-impl AsMut<_cef_fill_layout_t> for FillLayout {
-    fn as_mut(&mut self) -> &mut _cef_fill_layout_t {
-        &mut self.0
-    }
-}
-impl Default for FillLayout {
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
-#[doc = "See [_cef_layout_t] for more documentation."]
-#[repr(transparent)]
-pub struct Layout(_cef_layout_t);
-impl From<_cef_layout_t> for Layout {
-    fn from(value: _cef_layout_t) -> Self {
-        Self(value)
-    }
-}
-impl Into<*const _cef_layout_t> for &Layout {
-    fn into(self) -> *const _cef_layout_t {
-        self.as_ref() as *const _cef_layout_t
-    }
-}
-impl Into<*mut _cef_layout_t> for &mut Layout {
-    fn into(self) -> *mut _cef_layout_t {
-        self.as_mut() as *mut _cef_layout_t
-    }
-}
-impl Into<_cef_layout_t> for Layout {
-    fn into(self) -> _cef_layout_t {
-        self.0
-    }
-}
-impl AsRef<_cef_layout_t> for Layout {
-    fn as_ref(&self) -> &_cef_layout_t {
-        &self.0
-    }
-}
-impl AsMut<_cef_layout_t> for Layout {
-    fn as_mut(&mut self) -> &mut _cef_layout_t {
-        &mut self.0
-    }
-}
-impl Default for Layout {
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
 pub trait ImplPanel: ImplView {
     fn as_window(&self) -> Window {
         unsafe { std::mem::zeroed() }
@@ -45565,7 +48146,7 @@ pub fn stream_reader_create_for_file(file_name: &CefStringUtf16) -> StreamReader
     unsafe { cef_stream_reader_create_for_file(file_name.as_raw()).as_wrapper() }
 }
 pub fn stream_reader_create_for_data(
-    data: &mut ::std::os::raw::c_void,
+    data: *mut ::std::os::raw::c_void,
     size: usize,
 ) -> StreamReader {
     unsafe { cef_stream_reader_create_for_data(data.as_raw(), size.as_raw()).as_wrapper() }
@@ -45743,7 +48324,7 @@ pub fn v8value_create_array(length: ::std::os::raw::c_int) -> V8value {
     unsafe { cef_v8value_create_array(length.as_raw()).as_wrapper() }
 }
 pub fn v8value_create_array_buffer(
-    buffer: &mut ::std::os::raw::c_void,
+    buffer: *mut ::std::os::raw::c_void,
     length: usize,
     release_callback: &mut V8arrayBufferReleaseCallback,
 ) -> V8value {
@@ -45753,7 +48334,7 @@ pub fn v8value_create_array_buffer(
     }
 }
 pub fn v8value_create_array_buffer_with_copy(
-    buffer: &mut ::std::os::raw::c_void,
+    buffer: *mut ::std::os::raw::c_void,
     length: usize,
 ) -> V8value {
     unsafe {
@@ -45803,7 +48384,7 @@ pub fn clear_scheme_handler_factories() -> ::std::os::raw::c_int {
 pub fn execute_process(
     args: &MainArgs,
     application: &mut App,
-    windows_sandbox_info: &mut ::std::os::raw::c_void,
+    windows_sandbox_info: *mut ::std::os::raw::c_void,
 ) -> ::std::os::raw::c_int {
     unsafe {
         cef_execute_process(
@@ -45818,7 +48399,7 @@ pub fn initialize(
     args: &MainArgs,
     settings: &Settings,
     application: &mut App,
-    windows_sandbox_info: &mut ::std::os::raw::c_void,
+    windows_sandbox_info: *mut ::std::os::raw::c_void,
 ) -> ::std::os::raw::c_int {
     unsafe {
         cef_initialize(
@@ -45845,6 +48426,25 @@ pub fn run_message_loop() {
 pub fn quit_message_loop() {
     unsafe { cef_quit_message_loop() }
 }
+pub fn urlrequest_create(
+    request: &mut Request,
+    client: &mut UrlrequestClient,
+    request_context: &mut RequestContext,
+) -> Urlrequest {
+    unsafe {
+        cef_urlrequest_create(request.as_raw(), client.as_raw(), request_context.as_raw())
+            .as_wrapper()
+    }
+}
+pub fn label_button_create(delegate: &mut ButtonDelegate, text: &CefStringUtf16) -> LabelButton {
+    unsafe { cef_label_button_create(delegate.as_raw(), text.as_raw()).as_wrapper() }
+}
+pub fn menu_button_create(delegate: &mut MenuButtonDelegate, text: &CefStringUtf16) -> MenuButton {
+    unsafe { cef_menu_button_create(delegate.as_raw(), text.as_raw()).as_wrapper() }
+}
+pub fn textfield_create(delegate: &mut TextfieldDelegate) -> Textfield {
+    unsafe { cef_textfield_create(delegate.as_raw()).as_wrapper() }
+}
 pub fn browser_view_create(
     client: &mut Client,
     url: &CefStringUtf16,
@@ -45868,6 +48468,9 @@ pub fn browser_view_create(
 pub fn browser_view_get_for_browser(browser: &mut Browser) -> BrowserView {
     unsafe { cef_browser_view_get_for_browser(browser.as_raw()).as_wrapper() }
 }
+pub fn scroll_view_create(delegate: &mut ViewDelegate) -> ScrollView {
+    unsafe { cef_scroll_view_create(delegate.as_raw()).as_wrapper() }
+}
 pub fn display_get_primary() -> Display {
     unsafe { cef_display_get_primary().as_wrapper() }
 }
diff --git a/sys/src/bindings.rs b/sys/src/bindings.rs
index 1032bb8..c20b9a2 100644
--- a/sys/src/bindings.rs
+++ b/sys/src/bindings.rs
@@ -6145,16 +6145,6 @@ const _: () = {
 };
 #[doc = "\n Implement this structure to receive string values asynchronously.\n"]
 pub type cef_string_visitor_t = _cef_string_visitor_t;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct _cef_urlrequest_client_t {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct _cef_urlrequest_t {
-    _unused: [u8; 0],
-}
 #[doc = "\n Structure used to represent a frame in the browser window. When used in the\n browser process the functions of this structure may be called on any thread\n unless otherwise indicated in the comments. When used in the render process\n the functions of this structure may only be called on the main thread.\n"]
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -13354,6 +13344,222 @@ unsafe extern "C" {
     #[doc = "\n Quit the CEF message loop that was started by calling\n cef_run_message_loop(). This function should only be called on the main\n application thread and only if cef_run_message_loop() was used.\n"]
     pub fn cef_quit_message_loop();
 }
+#[doc = "\n Structure used to make a URL request. URL requests are not associated with a\n browser instance so no cef_client_t callbacks will be executed. URL requests\n can be created on any valid CEF thread in either the browser or render\n process. Once created the functions of the URL request object must be\n accessed on the same thread that created it.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_urlrequest_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_base_ref_counted_t,
+    #[doc = "\n Returns the request object used to create this URL request. The returned\n object is read-only and should not be modified.\n"]
+    pub get_request: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_urlrequest_t) -> *mut _cef_request_t,
+    >,
+    #[doc = "\n Returns the client.\n"]
+    pub get_client: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_urlrequest_t) -> *mut _cef_urlrequest_client_t,
+    >,
+    #[doc = "\n Returns the request status.\n"]
+    pub get_request_status: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_urlrequest_t) -> cef_urlrequest_status_t,
+    >,
+    #[doc = "\n Returns the request error if status is UR_CANCELED or UR_FAILED, or 0\n otherwise.\n"]
+    pub get_request_error: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_urlrequest_t) -> cef_errorcode_t,
+    >,
+    #[doc = "\n Returns the response, or NULL if no response information is available.\n Response information will only be available after the upload has\n completed. The returned object is read-only and should not be modified.\n"]
+    pub get_response: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_urlrequest_t) -> *mut _cef_response_t,
+    >,
+    #[doc = "\n Returns true (1) if the response body was served from the cache. This\n includes responses for which revalidation was required.\n"]
+    pub response_was_cached: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_urlrequest_t) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Cancel the request.\n"]
+    pub cancel: ::std::option::Option<unsafe extern "C" fn(self_: *mut _cef_urlrequest_t)>,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_urlrequest_t"][::std::mem::size_of::<_cef_urlrequest_t>() - 96usize];
+    ["Alignment of _cef_urlrequest_t"][::std::mem::align_of::<_cef_urlrequest_t>() - 8usize];
+    ["Offset of field: _cef_urlrequest_t::base"]
+        [::std::mem::offset_of!(_cef_urlrequest_t, base) - 0usize];
+    ["Offset of field: _cef_urlrequest_t::get_request"]
+        [::std::mem::offset_of!(_cef_urlrequest_t, get_request) - 40usize];
+    ["Offset of field: _cef_urlrequest_t::get_client"]
+        [::std::mem::offset_of!(_cef_urlrequest_t, get_client) - 48usize];
+    ["Offset of field: _cef_urlrequest_t::get_request_status"]
+        [::std::mem::offset_of!(_cef_urlrequest_t, get_request_status) - 56usize];
+    ["Offset of field: _cef_urlrequest_t::get_request_error"]
+        [::std::mem::offset_of!(_cef_urlrequest_t, get_request_error) - 64usize];
+    ["Offset of field: _cef_urlrequest_t::get_response"]
+        [::std::mem::offset_of!(_cef_urlrequest_t, get_response) - 72usize];
+    ["Offset of field: _cef_urlrequest_t::response_was_cached"]
+        [::std::mem::offset_of!(_cef_urlrequest_t, response_was_cached) - 80usize];
+    ["Offset of field: _cef_urlrequest_t::cancel"]
+        [::std::mem::offset_of!(_cef_urlrequest_t, cancel) - 88usize];
+};
+#[doc = "\n Structure used to make a URL request. URL requests are not associated with a\n browser instance so no cef_client_t callbacks will be executed. URL requests\n can be created on any valid CEF thread in either the browser or render\n process. Once created the functions of the URL request object must be\n accessed on the same thread that created it.\n"]
+pub type cef_urlrequest_t = _cef_urlrequest_t;
+unsafe extern "C" {
+    #[doc = "\n Create a new URL request that is not associated with a specific browser or\n frame. Use cef_frame_t::CreateURLRequest instead if you want the request to\n have this association, in which case it may be handled differently (see\n documentation on that function). A request created with this function may\n only originate from the browser process, and will behave as follows:\n   - It may be intercepted by the client via CefResourceRequestHandler or\n     CefSchemeHandlerFactory.\n   - POST data may only contain only a single element of type PDE_TYPE_FILE\n     or PDE_TYPE_BYTES.\n   - If |request_context| is empty the global request context will be used.\n\n The |request| object will be marked as read-only after calling this\n function.\n"]
+    pub fn cef_urlrequest_create(
+        request: *mut _cef_request_t,
+        client: *mut _cef_urlrequest_client_t,
+        request_context: *mut _cef_request_context_t,
+    ) -> *mut cef_urlrequest_t;
+}
+#[doc = "\n Structure that should be implemented by the cef_urlrequest_t client. The\n functions of this structure will be called on the same thread that created\n the request unless otherwise documented.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_urlrequest_client_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_base_ref_counted_t,
+    #[doc = "\n Notifies the client that the request has completed. Use the\n cef_urlrequest_t::GetRequestStatus function to determine if the request\n was successful or not.\n"]
+    pub on_request_complete: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_urlrequest_client_t, request: *mut _cef_urlrequest_t),
+    >,
+    #[doc = "\n Notifies the client of upload progress. |current| denotes the number of\n bytes sent so far and |total| is the total size of uploading data (or -1\n if chunked upload is enabled). This function will only be called if the\n UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request.\n"]
+    pub on_upload_progress: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_urlrequest_client_t,
+            request: *mut _cef_urlrequest_t,
+            current: i64,
+            total: i64,
+        ),
+    >,
+    #[doc = "\n Notifies the client of download progress. |current| denotes the number of\n bytes received up to the call and |total| is the expected total size of\n the response (or -1 if not determined).\n"]
+    pub on_download_progress: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_urlrequest_client_t,
+            request: *mut _cef_urlrequest_t,
+            current: i64,
+            total: i64,
+        ),
+    >,
+    #[doc = "\n Called when some part of the response is read. |data| contains the current\n bytes received since the last call. This function will not be called if\n the UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request.\n"]
+    pub on_download_data: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_urlrequest_client_t,
+            request: *mut _cef_urlrequest_t,
+            data: *const ::std::os::raw::c_void,
+            data_length: usize,
+        ),
+    >,
+    #[doc = "\n Called on the IO thread when the browser needs credentials from the user.\n |isProxy| indicates whether the host is a proxy server. |host| contains\n the hostname and |port| contains the port number. Return true (1) to\n continue the request and call cef_auth_callback_t::cont() when the\n authentication information is available. If the request has an associated\n browser/frame then returning false (0) will result in a call to\n GetAuthCredentials on the cef_request_handler_t associated with that\n browser, if any. Otherwise, returning false (0) will cancel the request\n immediately. This function will only be called for requests initiated from\n the browser process.\n"]
+    pub get_auth_credentials: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_urlrequest_client_t,
+            isProxy: ::std::os::raw::c_int,
+            host: *const cef_string_t,
+            port: ::std::os::raw::c_int,
+            realm: *const cef_string_t,
+            scheme: *const cef_string_t,
+            callback: *mut _cef_auth_callback_t,
+        ) -> ::std::os::raw::c_int,
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_urlrequest_client_t"]
+        [::std::mem::size_of::<_cef_urlrequest_client_t>() - 80usize];
+    ["Alignment of _cef_urlrequest_client_t"]
+        [::std::mem::align_of::<_cef_urlrequest_client_t>() - 8usize];
+    ["Offset of field: _cef_urlrequest_client_t::base"]
+        [::std::mem::offset_of!(_cef_urlrequest_client_t, base) - 0usize];
+    ["Offset of field: _cef_urlrequest_client_t::on_request_complete"]
+        [::std::mem::offset_of!(_cef_urlrequest_client_t, on_request_complete) - 40usize];
+    ["Offset of field: _cef_urlrequest_client_t::on_upload_progress"]
+        [::std::mem::offset_of!(_cef_urlrequest_client_t, on_upload_progress) - 48usize];
+    ["Offset of field: _cef_urlrequest_client_t::on_download_progress"]
+        [::std::mem::offset_of!(_cef_urlrequest_client_t, on_download_progress) - 56usize];
+    ["Offset of field: _cef_urlrequest_client_t::on_download_data"]
+        [::std::mem::offset_of!(_cef_urlrequest_client_t, on_download_data) - 64usize];
+    ["Offset of field: _cef_urlrequest_client_t::get_auth_credentials"]
+        [::std::mem::offset_of!(_cef_urlrequest_client_t, get_auth_credentials) - 72usize];
+};
+#[doc = "\n Structure that should be implemented by the cef_urlrequest_t client. The\n functions of this structure will be called on the same thread that created\n the request unless otherwise documented.\n"]
+pub type cef_urlrequest_client_t = _cef_urlrequest_client_t;
+#[doc = "\n A Layout handles the sizing of the children of a Panel according to\n implementation-specific heuristics. Methods must be called on the browser\n process UI thread unless otherwise indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_layout_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_base_ref_counted_t,
+    #[doc = "\n Returns this Layout as a BoxLayout or NULL if this is not a BoxLayout.\n"]
+    pub as_box_layout: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_layout_t) -> *mut _cef_box_layout_t,
+    >,
+    #[doc = "\n Returns this Layout as a FillLayout or NULL if this is not a FillLayout.\n"]
+    pub as_fill_layout: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_layout_t) -> *mut _cef_fill_layout_t,
+    >,
+    #[doc = "\n Returns true (1) if this Layout is valid.\n"]
+    pub is_valid: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_layout_t) -> ::std::os::raw::c_int,
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_layout_t"][::std::mem::size_of::<_cef_layout_t>() - 64usize];
+    ["Alignment of _cef_layout_t"][::std::mem::align_of::<_cef_layout_t>() - 8usize];
+    ["Offset of field: _cef_layout_t::base"][::std::mem::offset_of!(_cef_layout_t, base) - 0usize];
+    ["Offset of field: _cef_layout_t::as_box_layout"]
+        [::std::mem::offset_of!(_cef_layout_t, as_box_layout) - 40usize];
+    ["Offset of field: _cef_layout_t::as_fill_layout"]
+        [::std::mem::offset_of!(_cef_layout_t, as_fill_layout) - 48usize];
+    ["Offset of field: _cef_layout_t::is_valid"]
+        [::std::mem::offset_of!(_cef_layout_t, is_valid) - 56usize];
+};
+#[doc = "\n A Layout handles the sizing of the children of a Panel according to\n implementation-specific heuristics. Methods must be called on the browser\n process UI thread unless otherwise indicated.\n"]
+pub type cef_layout_t = _cef_layout_t;
+#[doc = "\n A Layout manager that arranges child views vertically or horizontally in a\n side-by-side fashion with spacing around and between the child views. The\n child views are always sized according to their preferred size. If the\n host's bounds provide insufficient space, child views will be clamped.\n Excess space will not be distributed. Methods must be called on the browser\n process UI thread unless otherwise indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_box_layout_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_layout_t,
+    #[doc = "\n Set the flex weight for the given |view|. Using the preferred size as the\n basis, free space along the main axis is distributed to views in the ratio\n of their flex weights. Similarly, if the views will overflow the parent,\n space is subtracted in these ratios. A flex of 0 means this view is not\n resized. Flex values must not be negative.\n"]
+    pub set_flex_for_view: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_box_layout_t,
+            view: *mut _cef_view_t,
+            flex: ::std::os::raw::c_int,
+        ),
+    >,
+    #[doc = "\n Clears the flex for the given |view|, causing it to use the default flex\n specified via cef_box_layout_tSettings.default_flex.\n"]
+    pub clear_flex_for_view: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_box_layout_t, view: *mut _cef_view_t),
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_box_layout_t"][::std::mem::size_of::<_cef_box_layout_t>() - 80usize];
+    ["Alignment of _cef_box_layout_t"][::std::mem::align_of::<_cef_box_layout_t>() - 8usize];
+    ["Offset of field: _cef_box_layout_t::base"]
+        [::std::mem::offset_of!(_cef_box_layout_t, base) - 0usize];
+    ["Offset of field: _cef_box_layout_t::set_flex_for_view"]
+        [::std::mem::offset_of!(_cef_box_layout_t, set_flex_for_view) - 64usize];
+    ["Offset of field: _cef_box_layout_t::clear_flex_for_view"]
+        [::std::mem::offset_of!(_cef_box_layout_t, clear_flex_for_view) - 72usize];
+};
+#[doc = "\n A Layout manager that arranges child views vertically or horizontally in a\n side-by-side fashion with spacing around and between the child views. The\n child views are always sized according to their preferred size. If the\n host's bounds provide insufficient space, child views will be clamped.\n Excess space will not be distributed. Methods must be called on the browser\n process UI thread unless otherwise indicated.\n"]
+pub type cef_box_layout_t = _cef_box_layout_t;
+#[doc = "\n A simple Layout that causes the associated Panel's one child to be sized to\n match the bounds of its parent. Methods must be called on the browser\n process UI thread unless otherwise indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_fill_layout_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_layout_t,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_fill_layout_t"][::std::mem::size_of::<_cef_fill_layout_t>() - 64usize];
+    ["Alignment of _cef_fill_layout_t"][::std::mem::align_of::<_cef_fill_layout_t>() - 8usize];
+    ["Offset of field: _cef_fill_layout_t::base"]
+        [::std::mem::offset_of!(_cef_fill_layout_t, base) - 0usize];
+};
+#[doc = "\n A simple Layout that causes the associated Panel's one child to be sized to\n match the bounds of its parent. Methods must be called on the browser\n process UI thread unless otherwise indicated.\n"]
+pub type cef_fill_layout_t = _cef_fill_layout_t;
 #[doc = "\n Implement this structure to handle view events. All size and position values\n are in density independent pixels (DIP) unless otherwise indicated. The\n functions of this structure will be called on the browser process UI thread\n unless otherwise indicated.\n"]
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -13467,122 +13673,6 @@ const _: () = {
 };
 #[doc = "\n Implement this structure to handle view events. All size and position values\n are in density independent pixels (DIP) unless otherwise indicated. The\n functions of this structure will be called on the browser process UI thread\n unless otherwise indicated.\n"]
 pub type cef_view_delegate_t = _cef_view_delegate_t;
-#[doc = "\n Implement this structure to handle BrowserView events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct _cef_browser_view_delegate_t {
-    #[doc = "\n Base structure.\n"]
-    pub base: cef_view_delegate_t,
-    #[doc = "\n Called when |browser| associated with |browser_view| is created. This\n function will be called after cef_life_span_handler_t::on_after_created()\n is called for |browser| and before on_popup_browser_view_created() is\n called for |browser|'s parent delegate if |browser| is a popup.\n"]
-    pub on_browser_created: ::std::option::Option<
-        unsafe extern "C" fn(
-            self_: *mut _cef_browser_view_delegate_t,
-            browser_view: *mut _cef_browser_view_t,
-            browser: *mut _cef_browser_t,
-        ),
-    >,
-    #[doc = "\n Called when |browser| associated with |browser_view| is destroyed. Release\n all references to |browser| and do not attempt to execute any functions on\n |browser| after this callback returns. This function will be called before\n cef_life_span_handler_t::on_before_close() is called for |browser|.\n"]
-    pub on_browser_destroyed: ::std::option::Option<
-        unsafe extern "C" fn(
-            self_: *mut _cef_browser_view_delegate_t,
-            browser_view: *mut _cef_browser_view_t,
-            browser: *mut _cef_browser_t,
-        ),
-    >,
-    #[doc = "\n Called before a new popup BrowserView is created. The popup originated\n from |browser_view|. |settings| and |client| are the values returned from\n cef_life_span_handler_t::on_before_popup(). |is_devtools| will be true (1)\n if the popup will be a DevTools browser. Return the delegate that will be\n used for the new popup BrowserView.\n"]
-    pub get_delegate_for_popup_browser_view: ::std::option::Option<
-        unsafe extern "C" fn(
-            self_: *mut _cef_browser_view_delegate_t,
-            browser_view: *mut _cef_browser_view_t,
-            settings: *const _cef_browser_settings_t,
-            client: *mut _cef_client_t,
-            is_devtools: ::std::os::raw::c_int,
-        ) -> *mut _cef_browser_view_delegate_t,
-    >,
-    #[doc = "\n Called after |popup_browser_view| is created. This function will be called\n after cef_life_span_handler_t::on_after_created() and on_browser_created()\n are called for the new popup browser. The popup originated from\n |browser_view|. |is_devtools| will be true (1) if the popup is a DevTools\n browser. Optionally add |popup_browser_view| to the views hierarchy\n yourself and return true (1). Otherwise return false (0) and a default\n cef_window_t will be created for the popup.\n"]
-    pub on_popup_browser_view_created: ::std::option::Option<
-        unsafe extern "C" fn(
-            self_: *mut _cef_browser_view_delegate_t,
-            browser_view: *mut _cef_browser_view_t,
-            popup_browser_view: *mut _cef_browser_view_t,
-            is_devtools: ::std::os::raw::c_int,
-        ) -> ::std::os::raw::c_int,
-    >,
-    #[doc = "\n Returns the Chrome toolbar type that will be available via\n cef_browser_view_t::get_chrome_toolbar(). See that function for related\n documentation.\n"]
-    pub get_chrome_toolbar_type: ::std::option::Option<
-        unsafe extern "C" fn(
-            self_: *mut _cef_browser_view_delegate_t,
-            browser_view: *mut _cef_browser_view_t,
-        ) -> cef_chrome_toolbar_type_t,
-    >,
-    #[doc = "\n Return true (1) to create frameless windows for Document picture-in-\n picture popups. Content in frameless windows should specify draggable\n regions using \"-webkit-app-region: drag\" CSS.\n"]
-    pub use_frameless_window_for_picture_in_picture: ::std::option::Option<
-        unsafe extern "C" fn(
-            self_: *mut _cef_browser_view_delegate_t,
-            browser_view: *mut _cef_browser_view_t,
-        ) -> ::std::os::raw::c_int,
-    >,
-    #[doc = "\n Called when |browser_view| receives a gesture command. Return true (1) to\n handle (or disable) a |gesture_command| or false (0) to propagate the\n gesture to the browser for default handling. With Chrome style these\n commands can also be handled via cef_command_handler_t::OnChromeCommand.\n"]
-    pub on_gesture_command: ::std::option::Option<
-        unsafe extern "C" fn(
-            self_: *mut _cef_browser_view_delegate_t,
-            browser_view: *mut _cef_browser_view_t,
-            gesture_command: cef_gesture_command_t,
-        ) -> ::std::os::raw::c_int,
-    >,
-    #[doc = "\n Optionally change the runtime style for this BrowserView. See\n cef_runtime_style_t documentation for details.\n"]
-    pub get_browser_runtime_style: ::std::option::Option<
-        unsafe extern "C" fn(self_: *mut _cef_browser_view_delegate_t) -> cef_runtime_style_t,
-    >,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of _cef_browser_view_delegate_t"]
-        [::std::mem::size_of::<_cef_browser_view_delegate_t>() - 192usize];
-    ["Alignment of _cef_browser_view_delegate_t"]
-        [::std::mem::align_of::<_cef_browser_view_delegate_t>() - 8usize];
-    ["Offset of field: _cef_browser_view_delegate_t::base"]
-        [::std::mem::offset_of!(_cef_browser_view_delegate_t, base) - 0usize];
-    ["Offset of field: _cef_browser_view_delegate_t::on_browser_created"]
-        [::std::mem::offset_of!(_cef_browser_view_delegate_t, on_browser_created) - 128usize];
-    ["Offset of field: _cef_browser_view_delegate_t::on_browser_destroyed"]
-        [::std::mem::offset_of!(_cef_browser_view_delegate_t, on_browser_destroyed) - 136usize];
-    ["Offset of field: _cef_browser_view_delegate_t::get_delegate_for_popup_browser_view"][::std::mem::offset_of!(
-        _cef_browser_view_delegate_t,
-        get_delegate_for_popup_browser_view
-    )
-        - 144usize];
-    ["Offset of field: _cef_browser_view_delegate_t::on_popup_browser_view_created"][::std::mem::offset_of!(
-        _cef_browser_view_delegate_t,
-        on_popup_browser_view_created
-    ) - 152usize];
-    ["Offset of field: _cef_browser_view_delegate_t::get_chrome_toolbar_type"]
-        [::std::mem::offset_of!(_cef_browser_view_delegate_t, get_chrome_toolbar_type) - 160usize];
-    ["Offset of field: _cef_browser_view_delegate_t::use_frameless_window_for_picture_in_picture"] [:: std :: mem :: offset_of ! (_cef_browser_view_delegate_t , use_frameless_window_for_picture_in_picture) - 168usize] ;
-    ["Offset of field: _cef_browser_view_delegate_t::on_gesture_command"]
-        [::std::mem::offset_of!(_cef_browser_view_delegate_t, on_gesture_command) - 176usize];
-    ["Offset of field: _cef_browser_view_delegate_t::get_browser_runtime_style"][::std::mem::offset_of!(
-        _cef_browser_view_delegate_t,
-        get_browser_runtime_style
-    ) - 184usize];
-};
-#[doc = "\n Implement this structure to handle BrowserView events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
-pub type cef_browser_view_delegate_t = _cef_browser_view_delegate_t;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct _cef_button_t {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct _cef_scroll_view_t {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct _cef_textfield_t {
-    _unused: [u8; 0],
-}
 #[doc = "\n A View is a rectangle within the views View hierarchy. It is the base\n structure for all Views. All size and position values are in density\n independent pixels (DIP) unless otherwise indicated. Methods must be called\n on the browser process UI thread unless otherwise indicated.\n"]
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -13926,6 +14016,622 @@ const _: () = {
 };
 #[doc = "\n A View is a rectangle within the views View hierarchy. It is the base\n structure for all Views. All size and position values are in density\n independent pixels (DIP) unless otherwise indicated. Methods must be called\n on the browser process UI thread unless otherwise indicated.\n"]
 pub type cef_view_t = _cef_view_t;
+#[doc = "\n A View representing a button. Depending on the specific type, the button\n could be implemented by a native control or custom rendered. Methods must be\n called on the browser process UI thread unless otherwise indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_button_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_view_t,
+    #[doc = "\n Returns this Button as a LabelButton or NULL if this is not a LabelButton.\n"]
+    pub as_label_button: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_button_t) -> *mut _cef_label_button_t,
+    >,
+    #[doc = "\n Sets the current display state of the Button.\n"]
+    pub set_state: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_button_t, state: cef_button_state_t),
+    >,
+    #[doc = "\n Returns the current display state of the Button.\n"]
+    pub get_state: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_button_t) -> cef_button_state_t,
+    >,
+    #[doc = "\n Sets the Button will use an ink drop effect for displaying state changes.\n"]
+    pub set_ink_drop_enabled: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_button_t, enabled: ::std::os::raw::c_int),
+    >,
+    #[doc = "\n Sets the tooltip text that will be displayed when the user hovers the\n mouse cursor over the Button.\n"]
+    pub set_tooltip_text: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_button_t, tooltip_text: *const cef_string_t),
+    >,
+    #[doc = "\n Sets the accessible name that will be exposed to assistive technology\n (AT).\n"]
+    pub set_accessible_name: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_button_t, name: *const cef_string_t),
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_button_t"][::std::mem::size_of::<_cef_button_t>() - 504usize];
+    ["Alignment of _cef_button_t"][::std::mem::align_of::<_cef_button_t>() - 8usize];
+    ["Offset of field: _cef_button_t::base"][::std::mem::offset_of!(_cef_button_t, base) - 0usize];
+    ["Offset of field: _cef_button_t::as_label_button"]
+        [::std::mem::offset_of!(_cef_button_t, as_label_button) - 456usize];
+    ["Offset of field: _cef_button_t::set_state"]
+        [::std::mem::offset_of!(_cef_button_t, set_state) - 464usize];
+    ["Offset of field: _cef_button_t::get_state"]
+        [::std::mem::offset_of!(_cef_button_t, get_state) - 472usize];
+    ["Offset of field: _cef_button_t::set_ink_drop_enabled"]
+        [::std::mem::offset_of!(_cef_button_t, set_ink_drop_enabled) - 480usize];
+    ["Offset of field: _cef_button_t::set_tooltip_text"]
+        [::std::mem::offset_of!(_cef_button_t, set_tooltip_text) - 488usize];
+    ["Offset of field: _cef_button_t::set_accessible_name"]
+        [::std::mem::offset_of!(_cef_button_t, set_accessible_name) - 496usize];
+};
+#[doc = "\n A View representing a button. Depending on the specific type, the button\n could be implemented by a native control or custom rendered. Methods must be\n called on the browser process UI thread unless otherwise indicated.\n"]
+pub type cef_button_t = _cef_button_t;
+#[doc = "\n Implement this structure to handle Button events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_button_delegate_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_view_delegate_t,
+    #[doc = "\n Called when |button| is pressed.\n"]
+    pub on_button_pressed: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_button_delegate_t, button: *mut _cef_button_t),
+    >,
+    #[doc = "\n Called when the state of |button| changes.\n"]
+    pub on_button_state_changed: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_button_delegate_t, button: *mut _cef_button_t),
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_button_delegate_t"][::std::mem::size_of::<_cef_button_delegate_t>() - 144usize];
+    ["Alignment of _cef_button_delegate_t"]
+        [::std::mem::align_of::<_cef_button_delegate_t>() - 8usize];
+    ["Offset of field: _cef_button_delegate_t::base"]
+        [::std::mem::offset_of!(_cef_button_delegate_t, base) - 0usize];
+    ["Offset of field: _cef_button_delegate_t::on_button_pressed"]
+        [::std::mem::offset_of!(_cef_button_delegate_t, on_button_pressed) - 128usize];
+    ["Offset of field: _cef_button_delegate_t::on_button_state_changed"]
+        [::std::mem::offset_of!(_cef_button_delegate_t, on_button_state_changed) - 136usize];
+};
+#[doc = "\n Implement this structure to handle Button events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
+pub type cef_button_delegate_t = _cef_button_delegate_t;
+#[doc = "\n LabelButton is a button with optional text and/or icon. Methods must be\n called on the browser process UI thread unless otherwise indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_label_button_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_button_t,
+    #[doc = "\n Returns this LabelButton as a MenuButton or NULL if this is not a\n MenuButton.\n"]
+    pub as_menu_button: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_label_button_t) -> *mut _cef_menu_button_t,
+    >,
+    #[doc = "\n Sets the text shown on the LabelButton. By default |text| will also be\n used as the accessible name.\n"]
+    pub set_text: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_label_button_t, text: *const cef_string_t),
+    >,
+    #[doc = "\n Returns the text shown on the LabelButton.\n"]
+    pub get_text: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_label_button_t) -> cef_string_userfree_t,
+    >,
+    #[doc = "\n Sets the image shown for |button_state|. When this Button is drawn if no\n image exists for the current state then the image for\n CEF_BUTTON_STATE_NORMAL, if any, will be shown.\n"]
+    pub set_image: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_label_button_t,
+            button_state: cef_button_state_t,
+            image: *mut _cef_image_t,
+        ),
+    >,
+    #[doc = "\n Returns the image shown for |button_state|. If no image exists for that\n state then the image for CEF_BUTTON_STATE_NORMAL will be returned.\n"]
+    pub get_image: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_label_button_t,
+            button_state: cef_button_state_t,
+        ) -> *mut _cef_image_t,
+    >,
+    #[doc = "\n Sets the text color shown for the specified button |for_state| to |color|.\n"]
+    pub set_text_color: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_label_button_t,
+            for_state: cef_button_state_t,
+            color: cef_color_t,
+        ),
+    >,
+    #[doc = "\n Sets the text colors shown for the non-disabled states to |color|.\n"]
+    pub set_enabled_text_colors: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_label_button_t, color: cef_color_t),
+    >,
+    #[doc = "\n Sets the font list. The format is \"<FONT_FAMILY_LIST>,[STYLES] <SIZE>\",\n where:\n - FONT_FAMILY_LIST is a comma-separated list of font family names,\n - STYLES is an optional space-separated list of style names (case-\n   sensitive \"Bold\" and \"Italic\" are supported), and\n - SIZE is an integer font size in pixels with the suffix \"px\".\n\n Here are examples of valid font description strings:\n - \"Arial, Helvetica, Bold Italic 14px\"\n - \"Arial, 14px\"\n"]
+    pub set_font_list: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_label_button_t, font_list: *const cef_string_t),
+    >,
+    #[doc = "\n Sets the horizontal alignment; reversed in RTL. Default is\n CEF_HORIZONTAL_ALIGNMENT_CENTER.\n"]
+    pub set_horizontal_alignment: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_label_button_t,
+            alignment: cef_horizontal_alignment_t,
+        ),
+    >,
+    #[doc = "\n Reset the minimum size of this LabelButton to |size|.\n"]
+    pub set_minimum_size: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_label_button_t, size: *const cef_size_t),
+    >,
+    #[doc = "\n Reset the maximum size of this LabelButton to |size|.\n"]
+    pub set_maximum_size: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_label_button_t, size: *const cef_size_t),
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_label_button_t"][::std::mem::size_of::<_cef_label_button_t>() - 592usize];
+    ["Alignment of _cef_label_button_t"][::std::mem::align_of::<_cef_label_button_t>() - 8usize];
+    ["Offset of field: _cef_label_button_t::base"]
+        [::std::mem::offset_of!(_cef_label_button_t, base) - 0usize];
+    ["Offset of field: _cef_label_button_t::as_menu_button"]
+        [::std::mem::offset_of!(_cef_label_button_t, as_menu_button) - 504usize];
+    ["Offset of field: _cef_label_button_t::set_text"]
+        [::std::mem::offset_of!(_cef_label_button_t, set_text) - 512usize];
+    ["Offset of field: _cef_label_button_t::get_text"]
+        [::std::mem::offset_of!(_cef_label_button_t, get_text) - 520usize];
+    ["Offset of field: _cef_label_button_t::set_image"]
+        [::std::mem::offset_of!(_cef_label_button_t, set_image) - 528usize];
+    ["Offset of field: _cef_label_button_t::get_image"]
+        [::std::mem::offset_of!(_cef_label_button_t, get_image) - 536usize];
+    ["Offset of field: _cef_label_button_t::set_text_color"]
+        [::std::mem::offset_of!(_cef_label_button_t, set_text_color) - 544usize];
+    ["Offset of field: _cef_label_button_t::set_enabled_text_colors"]
+        [::std::mem::offset_of!(_cef_label_button_t, set_enabled_text_colors) - 552usize];
+    ["Offset of field: _cef_label_button_t::set_font_list"]
+        [::std::mem::offset_of!(_cef_label_button_t, set_font_list) - 560usize];
+    ["Offset of field: _cef_label_button_t::set_horizontal_alignment"]
+        [::std::mem::offset_of!(_cef_label_button_t, set_horizontal_alignment) - 568usize];
+    ["Offset of field: _cef_label_button_t::set_minimum_size"]
+        [::std::mem::offset_of!(_cef_label_button_t, set_minimum_size) - 576usize];
+    ["Offset of field: _cef_label_button_t::set_maximum_size"]
+        [::std::mem::offset_of!(_cef_label_button_t, set_maximum_size) - 584usize];
+};
+#[doc = "\n LabelButton is a button with optional text and/or icon. Methods must be\n called on the browser process UI thread unless otherwise indicated.\n"]
+pub type cef_label_button_t = _cef_label_button_t;
+unsafe extern "C" {
+    #[doc = "\n Create a new LabelButton. A |delegate| must be provided to handle the button\n click. |text| will be shown on the LabelButton and used as the default\n accessible name.\n"]
+    pub fn cef_label_button_create(
+        delegate: *mut _cef_button_delegate_t,
+        text: *const cef_string_t,
+    ) -> *mut cef_label_button_t;
+}
+#[doc = "\n MenuButton pressed lock is released when this object is destroyed.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_menu_button_pressed_lock_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_base_ref_counted_t,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_menu_button_pressed_lock_t"]
+        [::std::mem::size_of::<_cef_menu_button_pressed_lock_t>() - 40usize];
+    ["Alignment of _cef_menu_button_pressed_lock_t"]
+        [::std::mem::align_of::<_cef_menu_button_pressed_lock_t>() - 8usize];
+    ["Offset of field: _cef_menu_button_pressed_lock_t::base"]
+        [::std::mem::offset_of!(_cef_menu_button_pressed_lock_t, base) - 0usize];
+};
+#[doc = "\n MenuButton pressed lock is released when this object is destroyed.\n"]
+pub type cef_menu_button_pressed_lock_t = _cef_menu_button_pressed_lock_t;
+#[doc = "\n Implement this structure to handle MenuButton events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_menu_button_delegate_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_button_delegate_t,
+    #[doc = "\n Called when |button| is pressed. Call cef_menu_button_t::show_menu() to\n show a popup menu at |screen_point|. When showing a custom popup such as a\n window keep a reference to |button_pressed_lock| until the popup is hidden\n to maintain the pressed button state.\n"]
+    pub on_menu_button_pressed: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_menu_button_delegate_t,
+            menu_button: *mut _cef_menu_button_t,
+            screen_point: *const cef_point_t,
+            button_pressed_lock: *mut _cef_menu_button_pressed_lock_t,
+        ),
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_menu_button_delegate_t"]
+        [::std::mem::size_of::<_cef_menu_button_delegate_t>() - 152usize];
+    ["Alignment of _cef_menu_button_delegate_t"]
+        [::std::mem::align_of::<_cef_menu_button_delegate_t>() - 8usize];
+    ["Offset of field: _cef_menu_button_delegate_t::base"]
+        [::std::mem::offset_of!(_cef_menu_button_delegate_t, base) - 0usize];
+    ["Offset of field: _cef_menu_button_delegate_t::on_menu_button_pressed"]
+        [::std::mem::offset_of!(_cef_menu_button_delegate_t, on_menu_button_pressed) - 144usize];
+};
+#[doc = "\n Implement this structure to handle MenuButton events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
+pub type cef_menu_button_delegate_t = _cef_menu_button_delegate_t;
+#[doc = "\n MenuButton is a button with optional text, icon and/or menu marker that\n shows a menu when clicked with the left mouse button. All size and position\n values are in density independent pixels (DIP) unless otherwise indicated.\n Methods must be called on the browser process UI thread unless otherwise\n indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_menu_button_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_label_button_t,
+    #[doc = "\n Show a menu with contents |menu_model|. |screen_point| specifies the menu\n position in screen coordinates. |anchor_position| specifies how the menu\n will be anchored relative to |screen_point|. This function should be\n called from cef_menu_button_delegate_t::on_menu_button_pressed().\n"]
+    pub show_menu: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_menu_button_t,
+            menu_model: *mut _cef_menu_model_t,
+            screen_point: *const cef_point_t,
+            anchor_position: cef_menu_anchor_position_t,
+        ),
+    >,
+    #[doc = "\n Show the menu for this button. Results in a call to\n cef_menu_button_delegate_t::on_menu_button_pressed().\n"]
+    pub trigger_menu: ::std::option::Option<unsafe extern "C" fn(self_: *mut _cef_menu_button_t)>,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_menu_button_t"][::std::mem::size_of::<_cef_menu_button_t>() - 608usize];
+    ["Alignment of _cef_menu_button_t"][::std::mem::align_of::<_cef_menu_button_t>() - 8usize];
+    ["Offset of field: _cef_menu_button_t::base"]
+        [::std::mem::offset_of!(_cef_menu_button_t, base) - 0usize];
+    ["Offset of field: _cef_menu_button_t::show_menu"]
+        [::std::mem::offset_of!(_cef_menu_button_t, show_menu) - 592usize];
+    ["Offset of field: _cef_menu_button_t::trigger_menu"]
+        [::std::mem::offset_of!(_cef_menu_button_t, trigger_menu) - 600usize];
+};
+#[doc = "\n MenuButton is a button with optional text, icon and/or menu marker that\n shows a menu when clicked with the left mouse button. All size and position\n values are in density independent pixels (DIP) unless otherwise indicated.\n Methods must be called on the browser process UI thread unless otherwise\n indicated.\n"]
+pub type cef_menu_button_t = _cef_menu_button_t;
+unsafe extern "C" {
+    #[doc = "\n Create a new MenuButton. A |delegate| must be provided to call show_menu()\n when the button is clicked. |text| will be shown on the MenuButton and used\n as the default accessible name. If |with_frame| is true (1) the button will\n have a visible frame at all times, center alignment, additional padding and\n a default minimum size of 70x33 DIP. If |with_frame| is false (0) the button\n will only have a visible frame on hover/press, left alignment, less padding\n and no default minimum size.\n"]
+    pub fn cef_menu_button_create(
+        delegate: *mut _cef_menu_button_delegate_t,
+        text: *const cef_string_t,
+    ) -> *mut cef_menu_button_t;
+}
+#[doc = "\n Implement this structure to handle Textfield events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_textfield_delegate_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_view_delegate_t,
+    #[doc = "\n Called when |textfield| receives a keyboard event. |event| contains\n information about the keyboard event. Return true (1) if the keyboard\n event was handled or false (0) otherwise for default handling.\n"]
+    pub on_key_event: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_textfield_delegate_t,
+            textfield: *mut _cef_textfield_t,
+            event: *const cef_key_event_t,
+        ) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Called after performing a user action that may change |textfield|.\n"]
+    pub on_after_user_action: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_textfield_delegate_t,
+            textfield: *mut _cef_textfield_t,
+        ),
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_textfield_delegate_t"]
+        [::std::mem::size_of::<_cef_textfield_delegate_t>() - 144usize];
+    ["Alignment of _cef_textfield_delegate_t"]
+        [::std::mem::align_of::<_cef_textfield_delegate_t>() - 8usize];
+    ["Offset of field: _cef_textfield_delegate_t::base"]
+        [::std::mem::offset_of!(_cef_textfield_delegate_t, base) - 0usize];
+    ["Offset of field: _cef_textfield_delegate_t::on_key_event"]
+        [::std::mem::offset_of!(_cef_textfield_delegate_t, on_key_event) - 128usize];
+    ["Offset of field: _cef_textfield_delegate_t::on_after_user_action"]
+        [::std::mem::offset_of!(_cef_textfield_delegate_t, on_after_user_action) - 136usize];
+};
+#[doc = "\n Implement this structure to handle Textfield events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
+pub type cef_textfield_delegate_t = _cef_textfield_delegate_t;
+#[doc = "\n A Textfield supports editing of text. This control is custom rendered with\n no platform-specific code. Methods must be called on the browser process UI\n thread unless otherwise indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_textfield_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_view_t,
+    #[doc = "\n Sets whether the text will be displayed as asterisks.\n"]
+    pub set_password_input: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, password_input: ::std::os::raw::c_int),
+    >,
+    #[doc = "\n Returns true (1) if the text will be displayed as asterisks.\n"]
+    pub is_password_input: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Sets whether the text will read-only.\n"]
+    pub set_read_only: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, read_only: ::std::os::raw::c_int),
+    >,
+    #[doc = "\n Returns true (1) if the text is read-only.\n"]
+    pub is_read_only: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Returns the currently displayed text.\n"]
+    pub get_text: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> cef_string_userfree_t,
+    >,
+    #[doc = "\n Sets the contents to |text|. The cursor will be moved to end of the text\n if the current position is outside of the text range.\n"]
+    pub set_text: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, text: *const cef_string_t),
+    >,
+    #[doc = "\n Appends |text| to the previously-existing text.\n"]
+    pub append_text: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, text: *const cef_string_t),
+    >,
+    #[doc = "\n Inserts |text| at the current cursor position replacing any selected text.\n"]
+    pub insert_or_replace_text: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, text: *const cef_string_t),
+    >,
+    #[doc = "\n Returns true (1) if there is any selected text.\n"]
+    pub has_selection: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Returns the currently selected text.\n"]
+    pub get_selected_text: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> cef_string_userfree_t,
+    >,
+    #[doc = "\n Selects all text. If |reversed| is true (1) the range will end at the\n logical beginning of the text; this generally shows the leading portion of\n text that overflows its display area.\n"]
+    pub select_all: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, reversed: ::std::os::raw::c_int),
+    >,
+    #[doc = "\n Clears the text selection and sets the caret to the end.\n"]
+    pub clear_selection: ::std::option::Option<unsafe extern "C" fn(self_: *mut _cef_textfield_t)>,
+    #[doc = "\n Returns the selected logical text range.\n"]
+    pub get_selected_range:
+        ::std::option::Option<unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> cef_range_t>,
+    #[doc = "\n Selects the specified logical text range.\n"]
+    pub select_range: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, range: *const cef_range_t),
+    >,
+    #[doc = "\n Returns the current cursor position.\n"]
+    pub get_cursor_position:
+        ::std::option::Option<unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> usize>,
+    #[doc = "\n Sets the text color.\n"]
+    pub set_text_color: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, color: cef_color_t),
+    >,
+    #[doc = "\n Returns the text color.\n"]
+    pub get_text_color:
+        ::std::option::Option<unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> cef_color_t>,
+    #[doc = "\n Sets the selection text color.\n"]
+    pub set_selection_text_color: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, color: cef_color_t),
+    >,
+    #[doc = "\n Returns the selection text color.\n"]
+    pub get_selection_text_color:
+        ::std::option::Option<unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> cef_color_t>,
+    #[doc = "\n Sets the selection background color.\n"]
+    pub set_selection_background_color: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, color: cef_color_t),
+    >,
+    #[doc = "\n Returns the selection background color.\n"]
+    pub get_selection_background_color:
+        ::std::option::Option<unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> cef_color_t>,
+    #[doc = "\n Sets the font list. The format is \"<FONT_FAMILY_LIST>,[STYLES] <SIZE>\",\n where:\n - FONT_FAMILY_LIST is a comma-separated list of font family names,\n - STYLES is an optional space-separated list of style names (case-\n   sensitive \"Bold\" and \"Italic\" are supported), and\n - SIZE is an integer font size in pixels with the suffix \"px\".\n\n Here are examples of valid font description strings:\n - \"Arial, Helvetica, Bold Italic 14px\"\n - \"Arial, 14px\"\n"]
+    pub set_font_list: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, font_list: *const cef_string_t),
+    >,
+    #[doc = "\n Applies |color| to the specified |range| without changing the default\n color. If |range| is NULL the color will be set on the complete text\n contents.\n"]
+    pub apply_text_color: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_textfield_t,
+            color: cef_color_t,
+            range: *const cef_range_t,
+        ),
+    >,
+    #[doc = "\n Applies |style| to the specified |range| without changing the default\n style. If |add| is true (1) the style will be added, otherwise the style\n will be removed. If |range| is NULL the style will be set on the complete\n text contents.\n"]
+    pub apply_text_style: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_textfield_t,
+            style: cef_text_style_t,
+            add: ::std::os::raw::c_int,
+            range: *const cef_range_t,
+        ),
+    >,
+    #[doc = "\n Returns true (1) if the action associated with the specified command id is\n enabled. See additional comments on execute_command().\n"]
+    pub is_command_enabled: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_textfield_t,
+            command_id: cef_text_field_commands_t,
+        ) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Performs the action associated with the specified command id.\n"]
+    pub execute_command: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, command_id: cef_text_field_commands_t),
+    >,
+    #[doc = "\n Clears Edit history.\n"]
+    pub clear_edit_history:
+        ::std::option::Option<unsafe extern "C" fn(self_: *mut _cef_textfield_t)>,
+    #[doc = "\n Sets the placeholder text that will be displayed when the Textfield is\n NULL.\n"]
+    pub set_placeholder_text: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, text: *const cef_string_t),
+    >,
+    #[doc = "\n Returns the placeholder text that will be displayed when the Textfield is\n NULL.\n"]
+    pub get_placeholder_text: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t) -> cef_string_userfree_t,
+    >,
+    #[doc = "\n Sets the placeholder text color.\n"]
+    pub set_placeholder_text_color: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, color: cef_color_t),
+    >,
+    #[doc = "\n Set the accessible name that will be exposed to assistive technology (AT).\n"]
+    pub set_accessible_name: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_textfield_t, name: *const cef_string_t),
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_textfield_t"][::std::mem::size_of::<_cef_textfield_t>() - 704usize];
+    ["Alignment of _cef_textfield_t"][::std::mem::align_of::<_cef_textfield_t>() - 8usize];
+    ["Offset of field: _cef_textfield_t::base"]
+        [::std::mem::offset_of!(_cef_textfield_t, base) - 0usize];
+    ["Offset of field: _cef_textfield_t::set_password_input"]
+        [::std::mem::offset_of!(_cef_textfield_t, set_password_input) - 456usize];
+    ["Offset of field: _cef_textfield_t::is_password_input"]
+        [::std::mem::offset_of!(_cef_textfield_t, is_password_input) - 464usize];
+    ["Offset of field: _cef_textfield_t::set_read_only"]
+        [::std::mem::offset_of!(_cef_textfield_t, set_read_only) - 472usize];
+    ["Offset of field: _cef_textfield_t::is_read_only"]
+        [::std::mem::offset_of!(_cef_textfield_t, is_read_only) - 480usize];
+    ["Offset of field: _cef_textfield_t::get_text"]
+        [::std::mem::offset_of!(_cef_textfield_t, get_text) - 488usize];
+    ["Offset of field: _cef_textfield_t::set_text"]
+        [::std::mem::offset_of!(_cef_textfield_t, set_text) - 496usize];
+    ["Offset of field: _cef_textfield_t::append_text"]
+        [::std::mem::offset_of!(_cef_textfield_t, append_text) - 504usize];
+    ["Offset of field: _cef_textfield_t::insert_or_replace_text"]
+        [::std::mem::offset_of!(_cef_textfield_t, insert_or_replace_text) - 512usize];
+    ["Offset of field: _cef_textfield_t::has_selection"]
+        [::std::mem::offset_of!(_cef_textfield_t, has_selection) - 520usize];
+    ["Offset of field: _cef_textfield_t::get_selected_text"]
+        [::std::mem::offset_of!(_cef_textfield_t, get_selected_text) - 528usize];
+    ["Offset of field: _cef_textfield_t::select_all"]
+        [::std::mem::offset_of!(_cef_textfield_t, select_all) - 536usize];
+    ["Offset of field: _cef_textfield_t::clear_selection"]
+        [::std::mem::offset_of!(_cef_textfield_t, clear_selection) - 544usize];
+    ["Offset of field: _cef_textfield_t::get_selected_range"]
+        [::std::mem::offset_of!(_cef_textfield_t, get_selected_range) - 552usize];
+    ["Offset of field: _cef_textfield_t::select_range"]
+        [::std::mem::offset_of!(_cef_textfield_t, select_range) - 560usize];
+    ["Offset of field: _cef_textfield_t::get_cursor_position"]
+        [::std::mem::offset_of!(_cef_textfield_t, get_cursor_position) - 568usize];
+    ["Offset of field: _cef_textfield_t::set_text_color"]
+        [::std::mem::offset_of!(_cef_textfield_t, set_text_color) - 576usize];
+    ["Offset of field: _cef_textfield_t::get_text_color"]
+        [::std::mem::offset_of!(_cef_textfield_t, get_text_color) - 584usize];
+    ["Offset of field: _cef_textfield_t::set_selection_text_color"]
+        [::std::mem::offset_of!(_cef_textfield_t, set_selection_text_color) - 592usize];
+    ["Offset of field: _cef_textfield_t::get_selection_text_color"]
+        [::std::mem::offset_of!(_cef_textfield_t, get_selection_text_color) - 600usize];
+    ["Offset of field: _cef_textfield_t::set_selection_background_color"]
+        [::std::mem::offset_of!(_cef_textfield_t, set_selection_background_color) - 608usize];
+    ["Offset of field: _cef_textfield_t::get_selection_background_color"]
+        [::std::mem::offset_of!(_cef_textfield_t, get_selection_background_color) - 616usize];
+    ["Offset of field: _cef_textfield_t::set_font_list"]
+        [::std::mem::offset_of!(_cef_textfield_t, set_font_list) - 624usize];
+    ["Offset of field: _cef_textfield_t::apply_text_color"]
+        [::std::mem::offset_of!(_cef_textfield_t, apply_text_color) - 632usize];
+    ["Offset of field: _cef_textfield_t::apply_text_style"]
+        [::std::mem::offset_of!(_cef_textfield_t, apply_text_style) - 640usize];
+    ["Offset of field: _cef_textfield_t::is_command_enabled"]
+        [::std::mem::offset_of!(_cef_textfield_t, is_command_enabled) - 648usize];
+    ["Offset of field: _cef_textfield_t::execute_command"]
+        [::std::mem::offset_of!(_cef_textfield_t, execute_command) - 656usize];
+    ["Offset of field: _cef_textfield_t::clear_edit_history"]
+        [::std::mem::offset_of!(_cef_textfield_t, clear_edit_history) - 664usize];
+    ["Offset of field: _cef_textfield_t::set_placeholder_text"]
+        [::std::mem::offset_of!(_cef_textfield_t, set_placeholder_text) - 672usize];
+    ["Offset of field: _cef_textfield_t::get_placeholder_text"]
+        [::std::mem::offset_of!(_cef_textfield_t, get_placeholder_text) - 680usize];
+    ["Offset of field: _cef_textfield_t::set_placeholder_text_color"]
+        [::std::mem::offset_of!(_cef_textfield_t, set_placeholder_text_color) - 688usize];
+    ["Offset of field: _cef_textfield_t::set_accessible_name"]
+        [::std::mem::offset_of!(_cef_textfield_t, set_accessible_name) - 696usize];
+};
+#[doc = "\n A Textfield supports editing of text. This control is custom rendered with\n no platform-specific code. Methods must be called on the browser process UI\n thread unless otherwise indicated.\n"]
+pub type cef_textfield_t = _cef_textfield_t;
+unsafe extern "C" {
+    #[doc = "\n Create a new Textfield.\n"]
+    pub fn cef_textfield_create(delegate: *mut _cef_textfield_delegate_t) -> *mut cef_textfield_t;
+}
+#[doc = "\n Implement this structure to handle BrowserView events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_browser_view_delegate_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_view_delegate_t,
+    #[doc = "\n Called when |browser| associated with |browser_view| is created. This\n function will be called after cef_life_span_handler_t::on_after_created()\n is called for |browser| and before on_popup_browser_view_created() is\n called for |browser|'s parent delegate if |browser| is a popup.\n"]
+    pub on_browser_created: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_browser_view_delegate_t,
+            browser_view: *mut _cef_browser_view_t,
+            browser: *mut _cef_browser_t,
+        ),
+    >,
+    #[doc = "\n Called when |browser| associated with |browser_view| is destroyed. Release\n all references to |browser| and do not attempt to execute any functions on\n |browser| after this callback returns. This function will be called before\n cef_life_span_handler_t::on_before_close() is called for |browser|.\n"]
+    pub on_browser_destroyed: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_browser_view_delegate_t,
+            browser_view: *mut _cef_browser_view_t,
+            browser: *mut _cef_browser_t,
+        ),
+    >,
+    #[doc = "\n Called before a new popup BrowserView is created. The popup originated\n from |browser_view|. |settings| and |client| are the values returned from\n cef_life_span_handler_t::on_before_popup(). |is_devtools| will be true (1)\n if the popup will be a DevTools browser. Return the delegate that will be\n used for the new popup BrowserView.\n"]
+    pub get_delegate_for_popup_browser_view: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_browser_view_delegate_t,
+            browser_view: *mut _cef_browser_view_t,
+            settings: *const _cef_browser_settings_t,
+            client: *mut _cef_client_t,
+            is_devtools: ::std::os::raw::c_int,
+        ) -> *mut _cef_browser_view_delegate_t,
+    >,
+    #[doc = "\n Called after |popup_browser_view| is created. This function will be called\n after cef_life_span_handler_t::on_after_created() and on_browser_created()\n are called for the new popup browser. The popup originated from\n |browser_view|. |is_devtools| will be true (1) if the popup is a DevTools\n browser. Optionally add |popup_browser_view| to the views hierarchy\n yourself and return true (1). Otherwise return false (0) and a default\n cef_window_t will be created for the popup.\n"]
+    pub on_popup_browser_view_created: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_browser_view_delegate_t,
+            browser_view: *mut _cef_browser_view_t,
+            popup_browser_view: *mut _cef_browser_view_t,
+            is_devtools: ::std::os::raw::c_int,
+        ) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Returns the Chrome toolbar type that will be available via\n cef_browser_view_t::get_chrome_toolbar(). See that function for related\n documentation.\n"]
+    pub get_chrome_toolbar_type: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_browser_view_delegate_t,
+            browser_view: *mut _cef_browser_view_t,
+        ) -> cef_chrome_toolbar_type_t,
+    >,
+    #[doc = "\n Return true (1) to create frameless windows for Document picture-in-\n picture popups. Content in frameless windows should specify draggable\n regions using \"-webkit-app-region: drag\" CSS.\n"]
+    pub use_frameless_window_for_picture_in_picture: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_browser_view_delegate_t,
+            browser_view: *mut _cef_browser_view_t,
+        ) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Called when |browser_view| receives a gesture command. Return true (1) to\n handle (or disable) a |gesture_command| or false (0) to propagate the\n gesture to the browser for default handling. With Chrome style these\n commands can also be handled via cef_command_handler_t::OnChromeCommand.\n"]
+    pub on_gesture_command: ::std::option::Option<
+        unsafe extern "C" fn(
+            self_: *mut _cef_browser_view_delegate_t,
+            browser_view: *mut _cef_browser_view_t,
+            gesture_command: cef_gesture_command_t,
+        ) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Optionally change the runtime style for this BrowserView. See\n cef_runtime_style_t documentation for details.\n"]
+    pub get_browser_runtime_style: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_browser_view_delegate_t) -> cef_runtime_style_t,
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_browser_view_delegate_t"]
+        [::std::mem::size_of::<_cef_browser_view_delegate_t>() - 192usize];
+    ["Alignment of _cef_browser_view_delegate_t"]
+        [::std::mem::align_of::<_cef_browser_view_delegate_t>() - 8usize];
+    ["Offset of field: _cef_browser_view_delegate_t::base"]
+        [::std::mem::offset_of!(_cef_browser_view_delegate_t, base) - 0usize];
+    ["Offset of field: _cef_browser_view_delegate_t::on_browser_created"]
+        [::std::mem::offset_of!(_cef_browser_view_delegate_t, on_browser_created) - 128usize];
+    ["Offset of field: _cef_browser_view_delegate_t::on_browser_destroyed"]
+        [::std::mem::offset_of!(_cef_browser_view_delegate_t, on_browser_destroyed) - 136usize];
+    ["Offset of field: _cef_browser_view_delegate_t::get_delegate_for_popup_browser_view"][::std::mem::offset_of!(
+        _cef_browser_view_delegate_t,
+        get_delegate_for_popup_browser_view
+    )
+        - 144usize];
+    ["Offset of field: _cef_browser_view_delegate_t::on_popup_browser_view_created"][::std::mem::offset_of!(
+        _cef_browser_view_delegate_t,
+        on_popup_browser_view_created
+    ) - 152usize];
+    ["Offset of field: _cef_browser_view_delegate_t::get_chrome_toolbar_type"]
+        [::std::mem::offset_of!(_cef_browser_view_delegate_t, get_chrome_toolbar_type) - 160usize];
+    ["Offset of field: _cef_browser_view_delegate_t::use_frameless_window_for_picture_in_picture"] [:: std :: mem :: offset_of ! (_cef_browser_view_delegate_t , use_frameless_window_for_picture_in_picture) - 168usize] ;
+    ["Offset of field: _cef_browser_view_delegate_t::on_gesture_command"]
+        [::std::mem::offset_of!(_cef_browser_view_delegate_t, on_gesture_command) - 176usize];
+    ["Offset of field: _cef_browser_view_delegate_t::get_browser_runtime_style"][::std::mem::offset_of!(
+        _cef_browser_view_delegate_t,
+        get_browser_runtime_style
+    ) - 184usize];
+};
+#[doc = "\n Implement this structure to handle BrowserView events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
+pub type cef_browser_view_delegate_t = _cef_browser_view_delegate_t;
 #[doc = "\n A View hosting a cef_browser_t instance. Methods must be called on the\n browser process UI thread unless otherwise indicated.\n"]
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -13986,6 +14692,67 @@ unsafe extern "C" {
         browser: *mut _cef_browser_t,
     ) -> *mut cef_browser_view_t;
 }
+#[doc = "\n A ScrollView will show horizontal and/or vertical scrollbars when necessary\n based on the size of the attached content view. Methods must be called on\n the browser process UI thread unless otherwise indicated.\n"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct _cef_scroll_view_t {
+    #[doc = "\n Base structure.\n"]
+    pub base: cef_view_t,
+    #[doc = "\n Set the content View. The content View must have a specified size (e.g.\n via cef_view_t::SetBounds or cef_view_delegate_t::GetPreferredSize).\n"]
+    pub set_content_view: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_scroll_view_t, view: *mut _cef_view_t),
+    >,
+    #[doc = "\n Returns the content View.\n"]
+    pub get_content_view: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_scroll_view_t) -> *mut _cef_view_t,
+    >,
+    #[doc = "\n Returns the visible region of the content View.\n"]
+    pub get_visible_content_rect:
+        ::std::option::Option<unsafe extern "C" fn(self_: *mut _cef_scroll_view_t) -> cef_rect_t>,
+    #[doc = "\n Returns true (1) if the horizontal scrollbar is currently showing.\n"]
+    pub has_horizontal_scrollbar: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_scroll_view_t) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Returns the height of the horizontal scrollbar.\n"]
+    pub get_horizontal_scrollbar_height: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_scroll_view_t) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Returns true (1) if the vertical scrollbar is currently showing.\n"]
+    pub has_vertical_scrollbar: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_scroll_view_t) -> ::std::os::raw::c_int,
+    >,
+    #[doc = "\n Returns the width of the vertical scrollbar.\n"]
+    pub get_vertical_scrollbar_width: ::std::option::Option<
+        unsafe extern "C" fn(self_: *mut _cef_scroll_view_t) -> ::std::os::raw::c_int,
+    >,
+}
+#[allow(clippy::unnecessary_operation, clippy::identity_op)]
+const _: () = {
+    ["Size of _cef_scroll_view_t"][::std::mem::size_of::<_cef_scroll_view_t>() - 512usize];
+    ["Alignment of _cef_scroll_view_t"][::std::mem::align_of::<_cef_scroll_view_t>() - 8usize];
+    ["Offset of field: _cef_scroll_view_t::base"]
+        [::std::mem::offset_of!(_cef_scroll_view_t, base) - 0usize];
+    ["Offset of field: _cef_scroll_view_t::set_content_view"]
+        [::std::mem::offset_of!(_cef_scroll_view_t, set_content_view) - 456usize];
+    ["Offset of field: _cef_scroll_view_t::get_content_view"]
+        [::std::mem::offset_of!(_cef_scroll_view_t, get_content_view) - 464usize];
+    ["Offset of field: _cef_scroll_view_t::get_visible_content_rect"]
+        [::std::mem::offset_of!(_cef_scroll_view_t, get_visible_content_rect) - 472usize];
+    ["Offset of field: _cef_scroll_view_t::has_horizontal_scrollbar"]
+        [::std::mem::offset_of!(_cef_scroll_view_t, has_horizontal_scrollbar) - 480usize];
+    ["Offset of field: _cef_scroll_view_t::get_horizontal_scrollbar_height"]
+        [::std::mem::offset_of!(_cef_scroll_view_t, get_horizontal_scrollbar_height) - 488usize];
+    ["Offset of field: _cef_scroll_view_t::has_vertical_scrollbar"]
+        [::std::mem::offset_of!(_cef_scroll_view_t, has_vertical_scrollbar) - 496usize];
+    ["Offset of field: _cef_scroll_view_t::get_vertical_scrollbar_width"]
+        [::std::mem::offset_of!(_cef_scroll_view_t, get_vertical_scrollbar_width) - 504usize];
+};
+#[doc = "\n A ScrollView will show horizontal and/or vertical scrollbars when necessary\n based on the size of the attached content view. Methods must be called on\n the browser process UI thread unless otherwise indicated.\n"]
+pub type cef_scroll_view_t = _cef_scroll_view_t;
+unsafe extern "C" {
+    #[doc = "\n Create a new ScrollView.\n"]
+    pub fn cef_scroll_view_create(delegate: *mut _cef_view_delegate_t) -> *mut cef_scroll_view_t;
+}
 #[doc = "\n This structure typically, but not always, corresponds to a physical display\n connected to the system. A fake Display may exist on a headless system, or a\n Display may correspond to a remote, virtual display. All size and position\n values are in density independent pixel (DIP) coordinates unless otherwise\n indicated. Methods must be called on the browser process UI thread unless\n otherwise indicated.\n"]
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -14230,21 +14997,6 @@ const _: () = {
 };
 #[doc = "\n Implement this structure to handle Panel events. The functions of this\n structure will be called on the browser process UI thread unless otherwise\n indicated.\n"]
 pub type cef_panel_delegate_t = _cef_panel_delegate_t;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct _cef_box_layout_t {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct _cef_fill_layout_t {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct _cef_layout_t {
-    _unused: [u8; 0],
-}
 #[doc = "\n A Panel is a container in the views hierarchy that can contain other Views\n as children. Methods must be called on the browser process UI thread unless\n otherwise indicated.\n"]
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
diff --git a/sys/wrapper.h b/sys/wrapper.h
index 525d5e9..fa239e7 100644
--- a/sys/wrapper.h
+++ b/sys/wrapper.h
@@ -1,6 +1,20 @@
 #include "include/capi/cef_base_capi.h"
+
 #include "include/capi/cef_app_capi.h"
 #include "include/capi/cef_client_capi.h"
-#include "include/capi/views/cef_browser_view_capi.h"
-#include "include/capi/views/cef_window_capi.h"
+#include "include/capi/cef_urlrequest_capi.h"
 
+#include "include/capi/views/cef_layout_capi.h"
+#include "include/capi/views/cef_box_layout_capi.h"
+#include "include/capi/views/cef_fill_layout_capi.h"
+
+#include "include/capi/views/cef_button_capi.h"
+#include "include/capi/views/cef_label_button_capi.h"
+#include "include/capi/views/cef_menu_button_capi.h"
+
+#include "include/capi/views/cef_textfield_capi.h"
+
+#include "include/capi/views/cef_browser_view_capi.h"
+#include "include/capi/views/cef_scroll_view_capi.h"
+
+#include "include/capi/views/cef_window_capi.h"