Merge pull request #45 from vhdirk/master

Regenerate with latest gir

examples/main.rs

@@ -26,7 +26,7 @@ extern crate webkit2gtk;
 #[cfg(feature = "v2_4")]
 use glib::ToVariant;
 use gtk::{ContainerExt, Inhibit, WidgetExt, Window, WindowType};
-use webkit2gtk::{SettingsExt, WebContext, WebContextExt, WebView, WebViewExt, WebViewExtManual};
+use webkit2gtk::{SettingsExt, WebContext, WebContextExt, WebView, WebViewExt};
 #[cfg(feature = "v2_6")]
 use webkit2gtk::UserContentManager;
 
@@ -53,8 +53,10 @@ fn main() {
 
     window.show_all();
 
-    webview.run_javascript("alert('Hello');");
-    webview.run_javascript_with_callback("42", |result| {
+    webview.run_javascript("alert('Hello');", None::<&gio::Cancellable>, |_result|{});
+
+    let cancellable = gio::Cancellable::new();
+    webview.run_javascript("42", Some(&cancellable), |result| {
         match result {
             Ok(result) => {
                 let context = result.get_global_context().unwrap();

src/auto/authentication_request.rs

@@ -7,41 +7,43 @@ use AuthenticationScheme;
 #[cfg(any(feature = "v2_2", feature = "dox"))]
 use Credential;
 use ffi;
-use glib;
 #[cfg(any(feature = "v2_2", feature = "dox"))]
-use glib::object::Downcast;
+use glib::GString;
+#[cfg(any(feature = "v2_2", feature = "dox"))]
+use glib::object::Cast;
 use glib::object::IsA;
 #[cfg(any(feature = "v2_2", feature = "dox"))]
 use glib::signal::SignalHandlerId;
 #[cfg(any(feature = "v2_2", feature = "dox"))]
-use glib::signal::connect;
+use glib::signal::connect_raw;
 use glib::translate::*;
+#[cfg(any(feature = "v2_2", feature = "dox"))]
 use glib_ffi;
-use gobject_ffi;
 #[cfg(any(feature = "v2_2", feature = "dox"))]
 use std::boxed::Box as Box_;
-use std::mem;
+use std::fmt;
 #[cfg(any(feature = "v2_2", feature = "dox"))]
 use std::mem::transmute;
-use std::ptr;
 
 glib_wrapper! {
-    pub struct AuthenticationRequest(Object<ffi::WebKitAuthenticationRequest, ffi::WebKitAuthenticationRequestClass>);
+    pub struct AuthenticationRequest(Object<ffi::WebKitAuthenticationRequest, ffi::WebKitAuthenticationRequestClass, AuthenticationRequestClass>);
 
     match fn {
         get_type => || ffi::webkit_authentication_request_get_type(),
     }
 }
 
-pub trait AuthenticationRequestExt {
+pub const NONE_AUTHENTICATION_REQUEST: Option<&AuthenticationRequest> = None;
+
+pub trait AuthenticationRequestExt: 'static {
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn can_save_credentials(&self) -> bool;
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn cancel(&self);
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
-    fn get_host(&self) -> Option<String>;
+    fn get_host(&self) -> Option<GString>;
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn get_port(&self) -> u32;
@@ -50,7 +52,7 @@ pub trait AuthenticationRequestExt {
     fn get_proposed_credential(&self) -> Option<Credential>;
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
-    fn get_realm(&self) -> Option<String>;
+    fn get_realm(&self) -> Option<GString>;
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn get_scheme(&self) -> AuthenticationScheme;
@@ -65,75 +67,75 @@ pub trait AuthenticationRequestExt {
     fn connect_cancelled<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
 }
 
-impl<O: IsA<AuthenticationRequest> + IsA<glib::object::Object>> AuthenticationRequestExt for O {
+impl<O: IsA<AuthenticationRequest>> AuthenticationRequestExt for O {
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn can_save_credentials(&self) -> bool {
         unsafe {
-            from_glib(ffi::webkit_authentication_request_can_save_credentials(self.to_glib_none().0))
+            from_glib(ffi::webkit_authentication_request_can_save_credentials(self.as_ref().to_glib_none().0))
         }
     }
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn cancel(&self) {
         unsafe {
-            ffi::webkit_authentication_request_cancel(self.to_glib_none().0);
+            ffi::webkit_authentication_request_cancel(self.as_ref().to_glib_none().0);
         }
     }
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
-    fn get_host(&self) -> Option<String> {
+    fn get_host(&self) -> Option<GString> {
         unsafe {
-            from_glib_none(ffi::webkit_authentication_request_get_host(self.to_glib_none().0))
+            from_glib_none(ffi::webkit_authentication_request_get_host(self.as_ref().to_glib_none().0))
         }
     }
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn get_port(&self) -> u32 {
         unsafe {
-            ffi::webkit_authentication_request_get_port(self.to_glib_none().0)
+            ffi::webkit_authentication_request_get_port(self.as_ref().to_glib_none().0)
         }
     }
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn get_proposed_credential(&self) -> Option<Credential> {
         unsafe {
-            from_glib_full(ffi::webkit_authentication_request_get_proposed_credential(self.to_glib_none().0))
+            from_glib_full(ffi::webkit_authentication_request_get_proposed_credential(self.as_ref().to_glib_none().0))
         }
     }
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
-    fn get_realm(&self) -> Option<String> {
+    fn get_realm(&self) -> Option<GString> {
         unsafe {
-            from_glib_none(ffi::webkit_authentication_request_get_realm(self.to_glib_none().0))
+            from_glib_none(ffi::webkit_authentication_request_get_realm(self.as_ref().to_glib_none().0))
         }
     }
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn get_scheme(&self) -> AuthenticationScheme {
         unsafe {
-            from_glib(ffi::webkit_authentication_request_get_scheme(self.to_glib_none().0))
+            from_glib(ffi::webkit_authentication_request_get_scheme(self.as_ref().to_glib_none().0))
         }
     }
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn is_for_proxy(&self) -> bool {
         unsafe {
-            from_glib(ffi::webkit_authentication_request_is_for_proxy(self.to_glib_none().0))
+            from_glib(ffi::webkit_authentication_request_is_for_proxy(self.as_ref().to_glib_none().0))
         }
     }
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn is_retry(&self) -> bool {
         unsafe {
-            from_glib(ffi::webkit_authentication_request_is_retry(self.to_glib_none().0))
+            from_glib(ffi::webkit_authentication_request_is_retry(self.as_ref().to_glib_none().0))
         }
     }
 
     #[cfg(any(feature = "v2_2", feature = "dox"))]
     fn connect_cancelled<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
         unsafe {
             let f: Box_<Box_<Fn(&Self) + 'static>> = Box_::new(Box_::new(f));
-            connect(self.to_glib_none().0, "cancelled",
+            connect_raw(self.as_ptr() as *mut _, b"cancelled\0".as_ptr() as *const _,
                 transmute(cancelled_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
         }
     }
@@ -143,5 +145,11 @@ impl<O: IsA<AuthenticationRequest> + IsA<glib::object::Object>> AuthenticationRe
 unsafe extern "C" fn cancelled_trampoline<P>(this: *mut ffi::WebKitAuthenticationRequest, f: glib_ffi::gpointer)
 where P: IsA<AuthenticationRequest> {
     let f: &&(Fn(&P) + 'static) = transmute(f);
-    f(&AuthenticationRequest::from_glib_borrow(this).downcast_unchecked())
+    f(&AuthenticationRequest::from_glib_borrow(this).unsafe_cast())
+}
+
+impl fmt::Display for AuthenticationRequest {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "AuthenticationRequest")
+    }
 }

src/auto/back_forward_list.rs

@@ -6,20 +6,19 @@ use BackForwardListItem;
 use ffi;
 use glib::object::IsA;
 use glib::translate::*;
-use glib_ffi;
-use gobject_ffi;
-use std::mem;
-use std::ptr;
+use std::fmt;
 
 glib_wrapper! {
-    pub struct BackForwardList(Object<ffi::WebKitBackForwardList, ffi::WebKitBackForwardListClass>);
+    pub struct BackForwardList(Object<ffi::WebKitBackForwardList, ffi::WebKitBackForwardListClass, BackForwardListClass>);
 
     match fn {
         get_type => || ffi::webkit_back_forward_list_get_type(),
     }
 }
 
-pub trait BackForwardListExt {
+pub const NONE_BACK_FORWARD_LIST: Option<&BackForwardList> = None;
+
+pub trait BackForwardListExt: 'static {
     fn get_back_item(&self) -> Option<BackForwardListItem>;
 
     fn get_back_list(&self) -> Vec<BackForwardListItem>;
@@ -44,59 +43,65 @@ pub trait BackForwardListExt {
 impl<O: IsA<BackForwardList>> BackForwardListExt for O {
     fn get_back_item(&self) -> Option<BackForwardListItem> {
         unsafe {
-            from_glib_none(ffi::webkit_back_forward_list_get_back_item(self.to_glib_none().0))
+            from_glib_none(ffi::webkit_back_forward_list_get_back_item(self.as_ref().to_glib_none().0))
         }
     }
 
     fn get_back_list(&self) -> Vec<BackForwardListItem> {
         unsafe {
-            FromGlibPtrContainer::from_glib_container(ffi::webkit_back_forward_list_get_back_list(self.to_glib_none().0))
+            FromGlibPtrContainer::from_glib_container(ffi::webkit_back_forward_list_get_back_list(self.as_ref().to_glib_none().0))
         }
     }
 
     fn get_back_list_with_limit(&self, limit: u32) -> Vec<BackForwardListItem> {
         unsafe {
-            FromGlibPtrContainer::from_glib_container(ffi::webkit_back_forward_list_get_back_list_with_limit(self.to_glib_none().0, limit))
+            FromGlibPtrContainer::from_glib_container(ffi::webkit_back_forward_list_get_back_list_with_limit(self.as_ref().to_glib_none().0, limit))
         }
     }
 
     fn get_current_item(&self) -> Option<BackForwardListItem> {
         unsafe {
-            from_glib_none(ffi::webkit_back_forward_list_get_current_item(self.to_glib_none().0))
+            from_glib_none(ffi::webkit_back_forward_list_get_current_item(self.as_ref().to_glib_none().0))
         }
     }
 
     fn get_forward_item(&self) -> Option<BackForwardListItem> {
         unsafe {
-            from_glib_none(ffi::webkit_back_forward_list_get_forward_item(self.to_glib_none().0))
+            from_glib_none(ffi::webkit_back_forward_list_get_forward_item(self.as_ref().to_glib_none().0))
         }
     }
 
     fn get_forward_list(&self) -> Vec<BackForwardListItem> {
         unsafe {
-            FromGlibPtrContainer::from_glib_container(ffi::webkit_back_forward_list_get_forward_list(self.to_glib_none().0))
+            FromGlibPtrContainer::from_glib_container(ffi::webkit_back_forward_list_get_forward_list(self.as_ref().to_glib_none().0))
         }
     }
 
     fn get_forward_list_with_limit(&self, limit: u32) -> Vec<BackForwardListItem> {
         unsafe {
-            FromGlibPtrContainer::from_glib_container(ffi::webkit_back_forward_list_get_forward_list_with_limit(self.to_glib_none().0, limit))
+            FromGlibPtrContainer::from_glib_container(ffi::webkit_back_forward_list_get_forward_list_with_limit(self.as_ref().to_glib_none().0, limit))
         }
     }
 
     fn get_length(&self) -> u32 {
         unsafe {
-            ffi::webkit_back_forward_list_get_length(self.to_glib_none().0)
+            ffi::webkit_back_forward_list_get_length(self.as_ref().to_glib_none().0)
         }
     }
 
     fn get_nth_item(&self, index: i32) -> Option<BackForwardListItem> {
         unsafe {
-            from_glib_none(ffi::webkit_back_forward_list_get_nth_item(self.to_glib_none().0, index))
+            from_glib_none(ffi::webkit_back_forward_list_get_nth_item(self.as_ref().to_glib_none().0, index))
         }
     }
 
     //fn connect_changed<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
     //    Unimplemented items_removed: *.Pointer
     //}
 }
+
+impl fmt::Display for BackForwardList {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "BackForwardList")
+    }
+}

src/auto/back_forward_list_item.rs

@@ -3,45 +3,51 @@
 // DO NOT EDIT
 
 use ffi;
+use glib::GString;
 use glib::object::IsA;
 use glib::translate::*;
-use glib_ffi;
-use gobject_ffi;
-use std::mem;
-use std::ptr;
+use std::fmt;
 
 glib_wrapper! {
-    pub struct BackForwardListItem(Object<ffi::WebKitBackForwardListItem, ffi::WebKitBackForwardListItemClass>);
+    pub struct BackForwardListItem(Object<ffi::WebKitBackForwardListItem, ffi::WebKitBackForwardListItemClass, BackForwardListItemClass>);
 
     match fn {
         get_type => || ffi::webkit_back_forward_list_item_get_type(),
     }
 }
 
-pub trait BackForwardListItemExt {
-    fn get_original_uri(&self) -> Option<String>;
+pub const NONE_BACK_FORWARD_LIST_ITEM: Option<&BackForwardListItem> = None;
 
-    fn get_title(&self) -> Option<String>;
+pub trait BackForwardListItemExt: 'static {
+    fn get_original_uri(&self) -> Option<GString>;
 
-    fn get_uri(&self) -> Option<String>;
+    fn get_title(&self) -> Option<GString>;
+
+    fn get_uri(&self) -> Option<GString>;
 }
 
 impl<O: IsA<BackForwardListItem>> BackForwardListItemExt for O {
-    fn get_original_uri(&self) -> Option<String> {
+    fn get_original_uri(&self) -> Option<GString> {
         unsafe {
-            from_glib_none(ffi::webkit_back_forward_list_item_get_original_uri(self.to_glib_none().0))
+            from_glib_none(ffi::webkit_back_forward_list_item_get_original_uri(self.as_ref().to_glib_none().0))
         }
     }
 
-    fn get_title(&self) -> Option<String> {
+    fn get_title(&self) -> Option<GString> {
         unsafe {
-            from_glib_none(ffi::webkit_back_forward_list_item_get_title(self.to_glib_none().0))
+            from_glib_none(ffi::webkit_back_forward_list_item_get_title(self.as_ref().to_glib_none().0))
         }
     }
 
-    fn get_uri(&self) -> Option<String> {
+    fn get_uri(&self) -> Option<GString> {
         unsafe {
-            from_glib_none(ffi::webkit_back_forward_list_item_get_uri(self.to_glib_none().0))
+            from_glib_none(ffi::webkit_back_forward_list_item_get_uri(self.as_ref().to_glib_none().0))
         }
     }
 }
+
+impl fmt::Display for BackForwardListItem {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "BackForwardListItem")
+    }
+}