Update travis secret

We need GVariant and to_glib_none() later,
which must be from the crate glib_sys.

.travis.yml

@@ -18,3 +18,4 @@ env:
   global:
   - TRAVIS_CARGO_NIGHTLY_FEATURE=""
   - secure: IjahTjjwmuvig/wTDMwxpk1F3Ywi2d0r17+JmOXHPdbfSfhi4puiTzsOgMjBhFtosTwcvlBeFwwFeTtl9KFNG165xm9Fqbhcez9sx+hS+EWZR/MBPFhKorJlgva0nuH8L1cxDUP+mDkcV/BdXCDeT7ml+y/FqEDAI4N0lwEsVMk=
+  - secure: B8QPcNgwOmbJ8dNJn/p/tE1cLeUOLTo/Oj7nOBkK1tatMgS6yfQFa5pyNEqeTyZAyNptssqSH1BpRC3RxTJ/b+kFzdy8Kq1nkJfp9R9zTY34w5gWukfmmTH4Qe2lyWY/DKL1lGVjb+8mroV9sPaS5Y4DqYHbeYtpWF8Gi27vIL4=

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 
 name = "libnotify"
-version = "0.4.0"
+version = "0.5.0"
-authors = ["Mika Attila <radiantstatue@gmail.com>"]
+authors = ["Mika Attila <radiantstatue@gmail.com>", "Julian Ospald <hasufell@posteo.de>"]
 license = "MIT"
 description = "Rust bindings to libnotify"
 readme = "README.md"
@@ -11,6 +11,9 @@ documentation = "http://crumblingstatue.github.io/doc/libnotify/libnotify/"
 keywords = ["libnotify", "notification"]
 
 [dependencies]
-libnotify-sys = "0.3"
+libnotify-sys = "^0.5.0"
-glib-2-0-sys = "0.46.0"
+gdk-pixbuf = "^0.1.3"
-gtypes = "0.2"
+gdk-pixbuf-sys = "^0.3.4"
+glib-sys = "^0.3.4"
+gtypes = "^0.2.0"
+glib = "^0.1.3"

examples/show.rs

@@ -4,7 +4,8 @@ fn main() {
     // Create a libnotify context
     let notify = libnotify::Context::new("myapp").unwrap();
     // Create a new notification and show it
-    let n = notify.new_notification("Summary", Some("Optional Body"), None).unwrap();
+    let n = notify.new_notification("Summary", Some("Optional Body"), None)
+        .unwrap();
     n.show().unwrap();
     // You can also use the .show() convenience method on the context
     notify.show("I am another notification", None, None).unwrap();

src/lib.rs

@@ -19,16 +19,53 @@
 
 #![warn(missing_docs)]
 
-extern crate libnotify_sys as sys;
+extern crate gdk_pixbuf;
-extern crate glib_2_0_sys as glib;
+extern crate gdk_pixbuf_sys;
+extern crate glib;
+extern crate glib_sys;
 extern crate gtypes;
+extern crate libnotify_sys as sys;
 
-use std::ffi::{self, CStr, CString};
+use gdk_pixbuf_sys::GdkPixbuf;
-use std::marker::PhantomData;
+use glib::translate::*;
-use std::fmt;
-use std::error::Error;
-
 use gtypes::{TRUE, FALSE};
+use std::error::Error;
+use std::ffi::{self, CStr, CString};
+use std::fmt;
+use std::marker::PhantomData;
+use std::os::raw::c_int;
+
+
+/// The urgency level of the notification.
+pub enum Urgency {
+    /// Low urgency. Used for unimportant notifications.
+    Low,
+    /// Normal urgency. Used for most standard notifications.
+    Normal,
+    /// Critical urgency. Used for very important notifications.
+    Critical,
+}
+
+impl From<sys::NotifyUrgency> for Urgency {
+    fn from(urgency: sys::NotifyUrgency) -> Urgency {
+        match urgency {
+            sys::NotifyUrgency::NotifyUrgencyLow => Urgency::Low,
+            sys::NotifyUrgency::NotifyUrgencyNormal => Urgency::Normal,
+            sys::NotifyUrgency::NotifyUrgencyCritical => Urgency::Critical,
+        }
+    }
+}
+
+impl From<Urgency> for sys::NotifyUrgency {
+    fn from(urgency: Urgency) -> sys::NotifyUrgency {
+        match urgency {
+            Urgency::Low => sys::NotifyUrgency::NotifyUrgencyLow,
+            Urgency::Normal => sys::NotifyUrgency::NotifyUrgencyNormal,
+            Urgency::Critical => sys::NotifyUrgency::NotifyUrgencyCritical,
+        }
+    }
+}
+
 
 /// Error that can happen on context creation
 #[derive(Debug)]
@@ -58,6 +95,7 @@ impl From<ffi::NulError> for ContextCreationError {
     }
 }
 
+
 #[derive(Debug)]
 /// An error that can happen when attempting to create a notification.
 pub enum NotificationCreationError {
@@ -65,6 +103,8 @@ pub enum NotificationCreationError {
     NulError(ffi::NulError),
     /// An unknown error happened.
     Unknown,
+    /// Invalid parameter passed to a glib function
+    InvalidParameter,
 }
 
 impl fmt::Display for NotificationCreationError {
@@ -73,6 +113,7 @@ impl fmt::Display for NotificationCreationError {
         match *self {
             NulError(ref e) => write!(f, "{}", e),
             Unknown => write!(f, "Unknown error"),
+            InvalidParameter => write!(f, "An invalid parameter was passed"),
         }
     }
 }
@@ -89,6 +130,7 @@ impl Error for NotificationCreationError {
     }
 }
 
+
 /// The context which within libnotify operates.
 ///
 /// Only one context can exist at a time.
@@ -112,6 +154,7 @@ impl Context {
         }
         Ok(Context)
     }
+
     /// Creates a new Notification.
     ///
     /// Arguments:
@@ -119,11 +162,12 @@ impl Context {
     /// - summary: Required summary text
     /// - body: Optional body text
     /// - icon: Optional icon theme icon name or filename
-    pub fn new_notification(&self,
+    pub fn new_notification
-                            summary: &str,
+        (&self,
-                            body: Option<&str>,
+         summary: &str,
-                            icon: Option<&str>)
+         body: Option<&str>,
-                            -> Result<Notification, NotificationCreationError> {
+         icon: Option<&str>)
+         -> Result<Notification, NotificationCreationError> {
         let summary = try!(CString::new(summary));
         let body = match body {
             Some(body) => Some(try!(CString::new(body))),
@@ -143,17 +187,20 @@ impl Context {
         };
 
         unsafe {
-            let n = sys::notify_notification_new(summary.as_ptr(), body_ptr, icon_ptr);
+            let n = sys::notify_notification_new(summary.as_ptr(),
+                                                 body_ptr,
+                                                 icon_ptr);
             if n.is_null() {
                 return Err(NotificationCreationError::Unknown);
             }
 
             Ok(Notification {
-                handle: n,
+                   handle: n,
-                _phantom: PhantomData,
+                   _phantom: PhantomData,
-            })
+               })
         }
     }
+
     /// Show a notification.
     ///
     /// This is a convenience method that creates a new notification,
@@ -177,6 +224,7 @@ impl Drop for Context {
     }
 }
 
+
 /// A passive pop-up notification
 pub struct Notification<'a> {
     handle: *mut sys::NotifyNotification,
@@ -188,20 +236,152 @@ impl<'a> Notification<'a> {
     /// on the screen.
     pub fn show(&'a self) -> Result<(), NotificationShowError> {
         unsafe {
-            let mut err: *mut glib::GError = std::ptr::null_mut();
+            let mut err: *mut glib_sys::GError = std::ptr::null_mut();
             sys::notify_notification_show(self.handle, &mut err);
             if !err.is_null() {
                 let result = Err(NotificationShowError {
-                    message: CStr::from_ptr((*err).message).to_string_lossy().into_owned(),
+                                     message: CStr::from_ptr((*err).message)
-                });
+                                         .to_string_lossy()
-                glib::g_error_free(err);
+                                         .into_owned(),
+                                 });
+                glib_sys::g_error_free(err);
                 return result;
             }
             Ok(())
         }
     }
+
+    /// Set the notification timeout. Note that the server might ignore
+    /// the timeout.
+    pub fn set_notification_timeout(&self, timeout: i32) {
+        let _timeout: c_int = From::from(timeout);
+
+        unsafe { sys::notify_notification_set_timeout(self.handle, _timeout) }
+    }
+
+    /// Updates the notification text and icon. This won't send the update
+    /// out and display it on the screen. For that, you will need to
+    /// call `.show()`.
+    pub fn update(&self,
+                  summary: &str,
+                  body: Option<&str>,
+                  icon: Option<&str>)
+                  -> Result<(), NotificationCreationError> {
+        let summary = try!(CString::new(summary));
+        let body = match body {
+            Some(body) => Some(try!(CString::new(body))),
+            None => None,
+        };
+        let body_ptr = match body {
+            Some(ref body) => body.as_ptr(),
+            None => std::ptr::null(),
+        };
+        let icon = match icon {
+            Some(icon) => Some(try!(CString::new(icon))),
+            None => None,
+        };
+        let icon_ptr = match icon {
+            Some(ref icon) => icon.as_ptr(),
+            None => std::ptr::null(),
+        };
+
+        unsafe {
+            let b = sys::notify_notification_update(self.handle,
+                                                    summary.as_ptr(),
+                                                    body_ptr,
+                                                    icon_ptr);
+            if b == FALSE {
+                return Err(NotificationCreationError::InvalidParameter);
+            }
+        }
+
+        return Ok(());
+    }
+
+    /// Sets a hint for `key` with value `value`. If value is `None`,
+    /// then key is unset.
+    pub fn set_hint(&self,
+                    key: &str,
+                    value: Option<glib::variant::Variant>)
+                    -> Result<(), NotificationCreationError> {
+        let key = try!(CString::new(key));
+
+        let gvalue: *mut glib_sys::GVariant = {
+            match value {
+                Some(ref value) => value.to_glib_none().0,
+                None => std::ptr::null_mut(),
+            }
+        };
+
+        unsafe {
+            sys::notify_notification_set_hint(self.handle, key.as_ptr(), gvalue)
+        }
+
+        return Ok(());
+    }
+
+    /// Sets the category of this notification. This can be used by the
+    /// notification server to filter or display the data in a certain way.
+    pub fn set_category(&self, category: &str) -> Result<(), NotificationCreationError> {
+        let category = try!(CString::new(category));
+        unsafe {
+            sys::notify_notification_set_category(self.handle,
+                                                   category.as_ptr());
+        }
+
+        return Ok(());
+    }
+
+    /// Sets the urgency level of this notification.
+    pub fn set_urgency(&self, urgency: Urgency) {
+        let urgency: sys::NotifyUrgency = From::from(urgency);
+
+        unsafe {
+            sys::notify_notification_set_urgency(self.handle,
+                                             urgency);
+        }
+    }
+
+    /// Sets the image in the notification from a Pixbuf.
+    pub fn set_image_from_pixbuf(&self, pixbuf: &gdk_pixbuf::Pixbuf) {
+        let pixbuf: *mut GdkPixbuf = pixbuf.to_glib_none().0;
+
+        unsafe {
+            sys::notify_notification_set_image_from_pixbuf(self.handle,
+                                                            pixbuf);
+        }
+    }
+
+    /// Clears all hints from the notification.
+    pub fn clear_hints(&self) {
+        unsafe {
+            sys::notify_notification_clear_hints(self.handle);
+        }
+    }
+
+    /// Synchronously tells the notification server to hide the
+    /// notification on the screen.
+    pub fn close(&self) -> Result<(), NotificationShowError> {
+        unsafe {
+            let mut err: *mut glib_sys::GError = std::ptr::null_mut();
+            sys::notify_notification_close(self.handle,
+                                           &mut err);
+
+            if !err.is_null() {
+                let result = Err(NotificationShowError {
+                                     message: CStr::from_ptr((*err).message)
+                                         .to_string_lossy()
+                                         .into_owned(),
+                                 });
+                glib_sys::g_error_free(err);
+                return result;
+            }
+        }
+        return Ok(());
+    }
 }
 
+
 /// An error that can happen when attempting to show a notification.
 #[derive(Debug)]
 pub struct NotificationShowError {