Merge branch 'sunweaver-pr/port-patches-from-indicator-notifications-by-trism'

Attributes GH PR #10: https://github.com/AyatanaIndicators/ayatana-indicator-notifications/pull/10

3 files changed, 403 insertions, 101 deletions

diff --git a/src/indicator-notifications-settings.c b/src/indicator-notifications-settings.c
index 439413e..510a0ec 100644
--- a/src/indicator-notifications-settings.c
+++ b/src/indicator-notifications-settings.c
@@ -21,8 +21,8 @@ typedef struct
 
   GSettings *settings;
 
-  GtkWidget *blacklist_treeview;
-  GtkWidget *blacklist_entry;
+  GtkWidget *filter_list_treeview;
+  GtkWidget *filter_list_entry;
 
   /* GtkTreeModel foreach variables */
   gboolean result;
@@ -43,29 +43,31 @@ static void indicator_notifications_settings_dispose(GObject *object);
 static void indicator_notifications_settings_activate(GApplication *app);
 
 /* Utility Functions */
-static void load_blacklist(IndicatorNotificationsSettings *self);
-static void save_blacklist(IndicatorNotificationsSettings *self);
+static void load_filter_list(IndicatorNotificationsSettings *self);
+static void load_filter_list_hints(IndicatorNotificationsSettings *self);
+static void save_filter_list(IndicatorNotificationsSettings *self);
 static gboolean foreach_check_duplicates(GtkTreeModel *model, GtkTreePath *path,
                                          GtkTreeIter *iter, gpointer user_data);
 static gboolean foreach_build_array(GtkTreeModel *model, GtkTreePath *path,
                                     GtkTreeIter *iter, gpointer user_data);
 
 /* Callbacks */
-static void blacklist_add_clicked_cb(GtkButton *button, gpointer user_data);
-static void blacklist_remove_clicked_cb(GtkButton *button, gpointer user_data);
+static void filter_list_add_clicked_cb(GtkButton *button, gpointer user_data);
+static void filter_list_remove_clicked_cb(GtkButton *button, gpointer user_data);
 static void button_toggled_cb(GtkToggleButton *button, gpointer user_data);
 static void max_items_changed_cb(GtkSpinButton *button, gpointer user_data);
+static gboolean filter_list_entry_focus_in_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data);
 
 static void
-load_blacklist(IndicatorNotificationsSettings *self)
+load_filter_list(IndicatorNotificationsSettings *self)
 {
-  GtkListStore *list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(self->blacklist_treeview)));
+  GtkListStore *list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(self->filter_list_treeview)));
   GtkTreeIter iter;
   gchar **items;
 
   gtk_list_store_clear(list);
 
-  items = g_settings_get_strv(self->settings, NOTIFICATIONS_KEY_BLACKLIST);
+  items = g_settings_get_strv(self->settings, NOTIFICATIONS_KEY_FILTER_LIST);
 
   for (int i = 0; items[i] != NULL; i++) {
     gtk_list_store_append(list, &iter);
@@ -76,19 +78,39 @@ load_blacklist(IndicatorNotificationsSettings *self)
 }
 
 static void
-save_blacklist(IndicatorNotificationsSettings *self)
+load_filter_list_hints(IndicatorNotificationsSettings *self)
 {
-  GtkListStore *list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(self->blacklist_treeview)));
+  GtkEntryCompletion *completion = gtk_entry_get_completion(GTK_ENTRY(self->filter_list_entry));
+  GtkListStore *list = GTK_LIST_STORE(gtk_entry_completion_get_model(completion));
+  GtkTreeIter iter;
   gchar **items;
 
-  /* build an array of the blacklist items */
+  gtk_list_store_clear(list);
+
+  items = g_settings_get_strv(self->settings, NOTIFICATIONS_KEY_FILTER_LIST_HINTS);
+
+  for (int i = 0; items[i] != NULL; i++) {
+    gtk_list_store_append(list, &iter);
+    gtk_list_store_set(list, &iter, 0, items[i], -1);
+  }
+
+  g_strfreev(items);
+}
+
+static void
+save_filter_list(IndicatorNotificationsSettings *self)
+{
+  GtkListStore *list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(self->filter_list_treeview)));
+  gchar **items;
+
+  /* build an array of the filter list items */
   self->array = g_ptr_array_new();
   gtk_tree_model_foreach(GTK_TREE_MODEL(list), foreach_build_array, self);
   g_ptr_array_add(self->array, NULL);
   items = (gchar **) g_ptr_array_free(self->array, FALSE);
   self->array = NULL;
 
-  g_settings_set_strv(self->settings, NOTIFICATIONS_KEY_BLACKLIST, (const gchar **) items);
+  g_settings_set_strv(self->settings, NOTIFICATIONS_KEY_FILTER_LIST, (const gchar **) items);
 
   g_strfreev(items);
 }
@@ -126,14 +148,14 @@ foreach_build_array(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, g
 }
 
 static void
-blacklist_add_clicked_cb(GtkButton *button, gpointer user_data)
+filter_list_add_clicked_cb(GtkButton *button, gpointer user_data)
 {
   IndicatorNotificationsSettings *self = (IndicatorNotificationsSettings *) user_data;
-  GtkListStore *list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(self->blacklist_treeview)));
+  GtkListStore *list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(self->filter_list_treeview)));
   GtkTreeIter iter;
 
   /* strip off the leading and trailing whitespace in case of user error */
-  self->text = g_strdup(gtk_entry_get_text(GTK_ENTRY(self->blacklist_entry)));
+  self->text = g_strdup(gtk_entry_get_text(GTK_ENTRY(self->filter_list_entry)));
   g_strstrip(self->text);
 
   if (strlen(self->text) > 0) {
@@ -144,12 +166,12 @@ blacklist_add_clicked_cb(GtkButton *button, gpointer user_data)
     if (self->result == FALSE) {
       gtk_list_store_append(list, &iter);
       gtk_list_store_set(list, &iter, COLUMN_APPNAME, self->text, -1);
-      save_blacklist(self);
+      save_filter_list(self);
     }
   }
 
   /* clear the entry */
-  gtk_entry_set_text(GTK_ENTRY(self->blacklist_entry), "");
+  gtk_entry_set_text(GTK_ENTRY(self->filter_list_entry), "");
 
   /* cleanup text */
   g_free(self->text);
@@ -157,19 +179,19 @@ blacklist_add_clicked_cb(GtkButton *button, gpointer user_data)
 }
 
 static void
-blacklist_remove_clicked_cb(GtkButton *button, gpointer user_data)
+filter_list_remove_clicked_cb(GtkButton *button, gpointer user_data)
 {
   IndicatorNotificationsSettings *self = (IndicatorNotificationsSettings *) user_data;
-  GtkListStore *list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(self->blacklist_treeview)));
+  GtkListStore *list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(self->filter_list_treeview)));
   GtkTreeIter iter;
   GtkTreeSelection *selection;
 
-  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->blacklist_treeview));
+  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->filter_list_treeview));
 
   if (gtk_tree_selection_get_selected(selection, NULL, &iter) == TRUE) {
     gtk_list_store_remove(list, &iter);
 
-    save_blacklist(self);
+    save_filter_list(self);
   }
 }
 
@@ -191,24 +213,37 @@ max_items_changed_cb(GtkSpinButton *button, gpointer user_data)
   g_settings_set_int(settings, NOTIFICATIONS_KEY_MAX_ITEMS, value);
 }
 
+static gboolean
+filter_list_entry_focus_in_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data)
+{
+  IndicatorNotificationsSettings *self = (IndicatorNotificationsSettings *) user_data;
+  load_filter_list_hints(self);
+  g_signal_emit_by_name(widget, "changed", NULL);
+  return FALSE;
+}
+
 static void
 indicator_notifications_settings_activate(GApplication *app)
 {
   GtkWidget *window;
   GtkWidget *frame;
   GtkWidget *vbox;
-  GtkWidget *button_1;
-  GtkWidget *button_2;
+  GtkWidget *button_cmc;
+  GtkWidget *button_hide_ind;
+  GtkWidget *button_dnd;
+  GtkWidget *button_swap_clr_s;
   GtkWidget *spin;
   GtkWidget *spin_label;
-  GtkWidget *blacklist_label;
-  GtkListStore *blacklist_list;
-  GtkWidget *blacklist_scroll;
+  GtkWidget *filter_list_label;
+  GtkListStore *filter_list_list;
+  GtkWidget *filter_list_scroll;
   GtkTreeViewColumn *column;
   GtkCellRenderer *renderer;
   GtkWidget *hbox;
-  GtkWidget *button_3;
-  GtkWidget *button_4;
+  GtkWidget *button_filter_list_rem;
+  GtkWidget *button_filter_list_add;
+  GtkEntryCompletion *entry_completion;
+  GtkListStore *entry_list;
 
   IndicatorNotificationsSettings *self = (IndicatorNotificationsSettings *) app;
 
@@ -241,22 +276,40 @@ indicator_notifications_settings_activate(GApplication *app)
   gtk_widget_show(vbox);
 
   /* clear-on-middle-click */
-  button_1 = gtk_check_button_new_with_label(_("Clear notifications on middle click"));
-  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_1),
+  button_cmc = gtk_check_button_new_with_label(_("Clear notifications on middle click"));
+  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_cmc),
       g_settings_get_boolean(self->settings, NOTIFICATIONS_KEY_CLEAR_MC));
-  g_object_set_data(G_OBJECT(button_1), SCHEMA_KEY, NOTIFICATIONS_KEY_CLEAR_MC);
-  g_signal_connect(button_1, "toggled", G_CALLBACK(button_toggled_cb), self->settings);
-  gtk_box_pack_start(GTK_BOX(vbox), button_1, FALSE, FALSE, 4);
-  gtk_widget_show(button_1);
+  g_object_set_data(G_OBJECT(button_cmc), SCHEMA_KEY, NOTIFICATIONS_KEY_CLEAR_MC);
+  g_signal_connect(button_cmc, "toggled", G_CALLBACK(button_toggled_cb), self->settings);
+  gtk_box_pack_start(GTK_BOX(vbox), button_cmc, FALSE, FALSE, 4);
+  gtk_widget_show(button_cmc);
 
   /* hide-indicator */
-  button_2 = gtk_check_button_new_with_label(_("Hide indicator"));
-  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_2),
+  button_hide_ind = gtk_check_button_new_with_label(_("Hide indicator"));
+  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_hide_ind),
       g_settings_get_boolean(self->settings, NOTIFICATIONS_KEY_HIDE_INDICATOR));
-  g_object_set_data(G_OBJECT(button_2), SCHEMA_KEY, NOTIFICATIONS_KEY_HIDE_INDICATOR);
-  g_signal_connect(button_2, "toggled", G_CALLBACK(button_toggled_cb), self->settings);
-  gtk_box_pack_start(GTK_BOX(vbox), button_2, FALSE, FALSE, 4);
-  gtk_widget_show(button_2);
+  g_object_set_data(G_OBJECT(button_hide_ind), SCHEMA_KEY, NOTIFICATIONS_KEY_HIDE_INDICATOR);
+  g_signal_connect(button_hide_ind, "toggled", G_CALLBACK(button_toggled_cb), self->settings);
+  gtk_box_pack_start(GTK_BOX(vbox), button_hide_ind, FALSE, FALSE, 4);
+  gtk_widget_show(button_hide_ind);
+
+  /* do-not-disturb */
+  button_dnd = gtk_check_button_new_with_label(_("Do not disturb"));
+  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_dnd),
+      g_settings_get_boolean(self->settings, NOTIFICATIONS_KEY_DND));
+  g_object_set_data(G_OBJECT(button_dnd), SCHEMA_KEY, NOTIFICATIONS_KEY_DND);
+  g_signal_connect(button_dnd, "toggled", G_CALLBACK(button_toggled_cb), self->settings);
+  gtk_box_pack_start(GTK_BOX(vbox), button_dnd, FALSE, FALSE, 4);
+  gtk_widget_show(button_dnd);
+
+  /* swap-clear-settings */
+  button_swap_clr_s = gtk_check_button_new_with_label(_("Swap \"Clear\" and \"Settings\" items"));
+  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_swap_clr_s),
+      g_settings_get_boolean(self->settings, NOTIFICATIONS_KEY_SWAP_CLEAR_SETTINGS));
+  g_object_set_data(G_OBJECT(button_swap_clr_s), SCHEMA_KEY, NOTIFICATIONS_KEY_SWAP_CLEAR_SETTINGS);
+  g_signal_connect(button_swap_clr_s, "toggled", G_CALLBACK(button_toggled_cb), self->settings);
+  gtk_box_pack_start(GTK_BOX(vbox), button_swap_clr_s, FALSE, FALSE, 4);
+  gtk_widget_show(button_swap_clr_s);
 
   /* max-items */
   /* FIXME: indicator does not change max items until restart... */
@@ -270,45 +323,55 @@ indicator_notifications_settings_activate(GApplication *app)
   gtk_box_pack_start(GTK_BOX(vbox), spin, FALSE, FALSE, 4);
   gtk_widget_show(spin);
 
-  /* blacklist */
-  blacklist_label = gtk_label_new(_("Discard notifications by application name"));
-  gtk_box_pack_start(GTK_BOX(vbox), blacklist_label, FALSE, FALSE, 4);
-  gtk_widget_show(blacklist_label);
+  /* filter-list */
+  filter_list_label = gtk_label_new(_("Discard notifications by application name"));
+  gtk_box_pack_start(GTK_BOX(vbox), filter_list_label, FALSE, FALSE, 4);
+  gtk_widget_show(filter_list_label);
 
-  blacklist_scroll = gtk_scrolled_window_new(NULL, NULL);
-  gtk_box_pack_start(GTK_BOX(vbox), blacklist_scroll, TRUE, TRUE, 4);
-  gtk_widget_show(blacklist_scroll);
+  filter_list_scroll = gtk_scrolled_window_new(NULL, NULL);
+  gtk_box_pack_start(GTK_BOX(vbox), filter_list_scroll, TRUE, TRUE, 4);
+  gtk_widget_show(filter_list_scroll);
 
-  blacklist_list = gtk_list_store_new(1, G_TYPE_STRING);
+  filter_list_list = gtk_list_store_new(1, G_TYPE_STRING);
 
   renderer = gtk_cell_renderer_text_new();
   column = gtk_tree_view_column_new_with_attributes("appname", renderer, "text", COLUMN_APPNAME, NULL);
 
-  self->blacklist_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(blacklist_list));
-  g_object_unref(blacklist_list);
-  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self->blacklist_treeview), FALSE);
-  gtk_tree_view_append_column(GTK_TREE_VIEW(self->blacklist_treeview), column);
-  load_blacklist(self);
-  gtk_container_add(GTK_CONTAINER(blacklist_scroll), self->blacklist_treeview);
-  gtk_widget_show(self->blacklist_treeview);
+  self->filter_list_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(filter_list_list));
+  g_object_unref(filter_list_list);
+  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self->filter_list_treeview), FALSE);
+  gtk_tree_view_append_column(GTK_TREE_VIEW(self->filter_list_treeview), column);
+  load_filter_list(self);
+  gtk_container_add(GTK_CONTAINER(filter_list_scroll), self->filter_list_treeview);
+  gtk_widget_show(self->filter_list_treeview);
 
   hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
   gtk_widget_show(hbox);
 
-  button_3 = gtk_button_new_with_label(_("Remove"));
-  g_signal_connect(button_3, "clicked", G_CALLBACK(blacklist_remove_clicked_cb), self);
-  gtk_box_pack_start(GTK_BOX(hbox), button_3, FALSE, FALSE, 2);
-  gtk_widget_show(button_3);
-
-  button_4 = gtk_button_new_with_label(_("Add"));
-  g_signal_connect(button_4, "clicked", G_CALLBACK(blacklist_add_clicked_cb), self);
-  gtk_box_pack_start(GTK_BOX(hbox), button_4, FALSE, FALSE, 2);
-  gtk_widget_show(button_4);
-
-  self->blacklist_entry = gtk_entry_new();
-  gtk_box_pack_start(GTK_BOX(hbox), self->blacklist_entry, TRUE, TRUE, 0);
-  gtk_widget_show(self->blacklist_entry);
+  button_filter_list_rem = gtk_button_new_with_label(_("Remove"));
+  g_signal_connect(button_filter_list_rem, "clicked", G_CALLBACK(filter_list_remove_clicked_cb), self);
+  gtk_box_pack_start(GTK_BOX(hbox), button_filter_list_rem, FALSE, FALSE, 2);
+  gtk_widget_show(button_filter_list_rem);
+
+  button_filter_list_add = gtk_button_new_with_label(_("Add"));
+  g_signal_connect(button_filter_list_add, "clicked", G_CALLBACK(filter_list_add_clicked_cb), self);
+  gtk_box_pack_start(GTK_BOX(hbox), button_filter_list_add, FALSE, FALSE, 2);
+  gtk_widget_show(button_filter_list_add);
+
+  self->filter_list_entry = gtk_entry_new();
+  gtk_box_pack_start(GTK_BOX(hbox), self->filter_list_entry, TRUE, TRUE, 0);
+  gtk_widget_show(self->filter_list_entry);
+
+  entry_completion = gtk_entry_completion_new();
+  entry_list = gtk_list_store_new(1, G_TYPE_STRING);
+  gtk_entry_completion_set_model(entry_completion, GTK_TREE_MODEL(entry_list));
+  gtk_entry_completion_set_text_column(entry_completion, 0);
+  gtk_entry_completion_set_minimum_key_length(entry_completion, 0);
+  gtk_entry_set_completion(GTK_ENTRY(self->filter_list_entry), entry_completion);
+  /* When we focus the entry, emit the changed signal so we get the hints immediately */
+  /* also update the filter list hints from gsettings */
+  g_signal_connect(self->filter_list_entry, "focus-in-event", G_CALLBACK(filter_list_entry_focus_in_cb), self);
 }
 
 static void
diff --git a/src/indicator-notifications.c b/src/indicator-notifications.c
index 07ccd26..56ddd7a 100644
--- a/src/indicator-notifications.c
+++ b/src/indicator-notifications.c
@@ -61,8 +61,10 @@ struct _IndicatorNotificationsPrivate {
   GList       *hidden_items;
 
   gboolean     clear_on_middle_click;
+  gboolean     do_not_disturb;
   gboolean     have_unread;
   gboolean     hide_indicator;
+  gboolean     swap_clear_settings;
 
   gint         max_items;
 
@@ -75,7 +77,9 @@ struct _IndicatorNotificationsPrivate {
 
   DBusSpy     *spy;
 
-  GHashTable  *blacklist;
+  GHashTable  *filter_list;
+
+  GList       *filter_list_hints;
 
   GSettings   *settings;
 };
@@ -83,8 +87,12 @@ struct _IndicatorNotificationsPrivate {
 #include "settings.h"
 
 #define INDICATOR_ICON_SIZE 22
-#define INDICATOR_ICON_READ   "ayatana-indicator-notification-read"
-#define INDICATOR_ICON_UNREAD "ayatana-indicator-notification-unread"
+#define INDICATOR_ICON_READ       "ayatana-indicator-notification-read"
+#define INDICATOR_ICON_UNREAD     "ayatana-indicator-notification-unread"
+#define INDICATOR_ICON_READ_DND   "ayatana-indicator-notification-read-dnd"
+#define INDICATOR_ICON_UNREAD_DND "ayatana-indicator-notification-unread-dnd"
+
+#define HINT_MAX 10
 
 GType indicator_notifications_get_type(void);
 
@@ -108,9 +116,16 @@ static void clear_menuitems(IndicatorNotifications *self);
 static void insert_menuitem(IndicatorNotifications *self, GtkWidget *item);
 static void remove_menuitem(IndicatorNotifications *self, GtkWidget *item);
 static void set_unread(IndicatorNotifications *self, gboolean unread);
-static void update_blacklist(IndicatorNotifications *self);
+static void update_unread(IndicatorNotifications *self);
+static void update_filter_list(IndicatorNotifications *self);
 static void update_clear_item_markup(IndicatorNotifications *self);
 static void update_indicator_visibility(IndicatorNotifications *self);
+static void load_filter_list_hints(IndicatorNotifications *self);
+static void save_filter_list_hints(IndicatorNotifications *self);
+static void update_filter_list_hints(IndicatorNotifications *self, Notification *notification);
+static void update_do_not_disturb(IndicatorNotifications *self);
+static void settings_try_set_boolean(const gchar *schema, const gchar *key, gboolean value);
+static void swap_clear_settings_items(IndicatorNotifications *self);
 
 /* Callbacks */
 static void clear_item_activated_cb(GtkMenuItem *menuitem, gpointer user_data);
@@ -193,16 +208,24 @@ indicator_notifications_init(IndicatorNotifications *self)
   self->priv->spy = dbus_spy_new();
   g_signal_connect(self->priv->spy, DBUS_SPY_SIGNAL_MESSAGE_RECEIVED, G_CALLBACK(message_received_cb), self);
 
-  /* Initialize an empty blacklist */
-  self->priv->blacklist = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
+  /* Initialize an empty filter list */
+  self->priv->filter_list = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
 
   /* Connect to GSettings */
   self->priv->settings = g_settings_new(NOTIFICATIONS_SCHEMA);
   self->priv->clear_on_middle_click = g_settings_get_boolean(self->priv->settings, NOTIFICATIONS_KEY_CLEAR_MC);
+  self->priv->do_not_disturb = g_settings_get_boolean(self->priv->settings, NOTIFICATIONS_KEY_DND);
   self->priv->hide_indicator = g_settings_get_boolean(self->priv->settings, NOTIFICATIONS_KEY_HIDE_INDICATOR);
   self->priv->max_items = g_settings_get_int(self->priv->settings, NOTIFICATIONS_KEY_MAX_ITEMS);
-  update_blacklist(self);
+  update_filter_list(self);
+  self->priv->swap_clear_settings = g_settings_get_boolean(self->priv->settings, NOTIFICATIONS_KEY_SWAP_CLEAR_SETTINGS);
+  if(self->priv->swap_clear_settings)
+    swap_clear_settings_items(self);
   g_signal_connect(self->priv->settings, "changed", G_CALLBACK(setting_changed_cb), self);
+
+  /* Set up filter-list hints */
+  self->priv->filter_list_hints = NULL;
+  load_filter_list_hints(self);
 }
 
 static void
@@ -240,9 +263,14 @@ indicator_notifications_dispose(GObject *object)
     self->priv->settings = NULL;
   }
 
-  if(self->priv->blacklist != NULL) {
-    g_hash_table_unref(self->priv->blacklist);
-    self->priv->blacklist = NULL;
+  if(self->priv->filter_list != NULL) {
+    g_hash_table_unref(self->priv->filter_list);
+    self->priv->filter_list = NULL;
+  }
+
+  if(self->priv->filter_list_hints != NULL) {
+    g_list_free_full(self->priv->filter_list_hints, g_free);
+    self->priv->filter_list_hints = NULL;
   }
 
   G_OBJECT_CLASS (indicator_notifications_parent_class)->dispose (object);
@@ -263,7 +291,8 @@ get_image(IndicatorObject *io)
 
   if(self->priv->image == NULL) {
     self->priv->image = GTK_IMAGE(gtk_image_new());
-    set_unread(self, FALSE);
+    /* We have to wait until the image is created to update do-not-disturb the first time */
+    update_do_not_disturb(self);
     update_indicator_visibility(self);
   }
 
@@ -417,35 +446,58 @@ set_unread(IndicatorNotifications *self, gboolean unread)
 {
   g_return_if_fail(IS_INDICATOR_NOTIFICATIONS(self));
 
-  if(unread) {
-    gtk_image_set_from_icon_name(self->priv->image, INDICATOR_ICON_UNREAD, GTK_ICON_SIZE_MENU);
+  self->priv->have_unread = unread;
+  update_unread(self);
+}
+
+/**
+ * update_unread:
+ * @self: the indicator object
+ *
+ * Updates the indicator icons.
+ **/
+static void
+update_unread(IndicatorNotifications *self)
+{
+  g_return_if_fail(IS_INDICATOR_NOTIFICATIONS(self));
+
+  if(self->priv->have_unread) {
+    if (self->priv->do_not_disturb) {
+      gtk_image_set_from_icon_name(self->priv->image, INDICATOR_ICON_UNREAD_DND, GTK_ICON_SIZE_MENU);
+    }
+    else {
+      gtk_image_set_from_icon_name(self->priv->image, INDICATOR_ICON_UNREAD, GTK_ICON_SIZE_MENU);
+    }
   }
   else {
-    gtk_image_set_from_icon_name(self->priv->image, INDICATOR_ICON_READ, GTK_ICON_SIZE_MENU);
+    if (self->priv->do_not_disturb) {
+      gtk_image_set_from_icon_name(self->priv->image, INDICATOR_ICON_READ_DND, GTK_ICON_SIZE_MENU);
+    }
+    else {
+      gtk_image_set_from_icon_name(self->priv->image, INDICATOR_ICON_READ, GTK_ICON_SIZE_MENU);
+    }
   }
-
-  self->priv->have_unread = unread;
 }
 
 /**
- * update_blacklist:
+ * update_filter_list:
  * @self: the indicator object
  *
- * Updates the blacklist from GSettings. This currently does not filter already
+ * Updates the filter list from GSettings. This currently does not filter already
  * allowed messages. It only applies to messages received in the future.
  **/
 static void
-update_blacklist(IndicatorNotifications *self)
+update_filter_list(IndicatorNotifications *self)
 {
   g_return_if_fail(IS_INDICATOR_NOTIFICATIONS(self));
-  g_return_if_fail(self->priv->blacklist != NULL);
+  g_return_if_fail(self->priv->filter_list != NULL);
 
-  g_hash_table_remove_all(self->priv->blacklist);
-  gchar **items = g_settings_get_strv(self->priv->settings, NOTIFICATIONS_KEY_BLACKLIST);
+  g_hash_table_remove_all(self->priv->filter_list);
+  gchar **items = g_settings_get_strv(self->priv->settings, NOTIFICATIONS_KEY_FILTER_LIST);
   int i;
 
   for(i = 0; items[i] != NULL; i++) {
-    g_hash_table_insert(self->priv->blacklist, g_strdup(items[i]), NULL);
+    g_hash_table_insert(self->priv->filter_list, g_strdup(items[i]), NULL);
   }
 
   g_strfreev(items);
@@ -501,6 +553,169 @@ update_indicator_visibility(IndicatorNotifications *self)
 }
 
 /**
+ * load_filter_list_hints:
+ * @self: the indicator object
+ *
+ * Loads the filter list hints from gsettings
+ **/
+static void
+load_filter_list_hints(IndicatorNotifications *self)
+{
+  g_return_if_fail(IS_INDICATOR_NOTIFICATIONS(self));
+  g_return_if_fail(self->priv->filter_list_hints == NULL);
+
+  gchar **items = g_settings_get_strv(self->priv->settings, NOTIFICATIONS_KEY_FILTER_LIST_HINTS);
+  int i;
+
+  for (i = 0; items[i] != NULL; i++) {
+    self->priv->filter_list_hints = g_list_prepend(self->priv->filter_list_hints, items[i]);
+  }
+
+  g_free(items);
+}
+
+/**
+ * save_filter_list_hints:
+ * @self: the indicator object
+ *
+ * Saves the filter list hints to gsettings
+ **/
+static void
+save_filter_list_hints(IndicatorNotifications *self)
+{
+  g_return_if_fail(IS_INDICATOR_NOTIFICATIONS(self));
+
+  gchar *hints[HINT_MAX + 1];
+  int i = 0;
+
+  GList *l;
+  for (l = self->priv->filter_list_hints; (l != NULL) && (i < HINT_MAX); l = l->next, i++) {
+    hints[i] = (gchar *) l->data;
+  }
+
+  hints[i] = NULL;
+
+  g_settings_set_strv(self->priv->settings, NOTIFICATIONS_KEY_FILTER_LIST_HINTS, (const gchar **) hints);
+}
+
+/**
+ * update_filter_list_hints:
+ * @self: the indicator object
+ *
+ * Adds an application name to the hints
+ **/
+static void
+update_filter_list_hints(IndicatorNotifications *self, Notification *notification)
+{
+  g_return_if_fail(IS_INDICATOR_NOTIFICATIONS(self));
+  g_return_if_fail(IS_NOTIFICATION(notification));
+
+  const gchar *appname = notification_get_app_name(notification);
+
+  /* Avoid duplicates */
+  GList *l;
+  for (l = self->priv->filter_list_hints; l != NULL; l = l->next) {
+    if (g_strcmp0(appname, (const gchar *) l->data) == 0)
+      return;
+  }
+
+  /* Add the appname */
+  self->priv->filter_list_hints = g_list_prepend(self->priv->filter_list_hints, g_strdup(appname));
+
+  /* Keep only a reasonable number */
+  while (g_list_length(self->priv->filter_list_hints) > HINT_MAX) {
+    GList *last = g_list_last(self->priv->filter_list_hints);
+    g_free(last->data);
+    self->priv->filter_list_hints = g_list_delete_link(self->priv->filter_list_hints, last);
+  }
+
+  /* Save the hints */
+  /* FIXME: maybe don't do this every update */
+  save_filter_list_hints(self);
+}
+
+/**
+ * update_do_not_disturb:
+ * @self: the indicator object
+ *
+ * Updates the icon with the do-not-disturb version and sets do-not-disturb options
+ * on external notification daemons that are supported.
+ **/
+static void
+update_do_not_disturb(IndicatorNotifications *self)
+{
+  g_return_if_fail(IS_INDICATOR_NOTIFICATIONS(self));
+
+  update_unread(self);
+
+  /* Mate do-not-disturb support */
+  settings_try_set_boolean(MATE_SCHEMA, MATE_KEY_DND, self->priv->do_not_disturb);
+}
+
+/**
+ * settings_try_set_boolean:
+ * @schema: the GSettings schema
+ * @key: the GSettings key
+ * @value: the boolean value
+ *
+ * Checks to see if the schema and key exist before setting the value.
+ */
+static void
+settings_try_set_boolean(const gchar *schema, const gchar *key, gboolean value)
+{
+  /* Check if we can access the schema */
+  GSettingsSchemaSource *source = g_settings_schema_source_get_default();
+  if (source == NULL) {
+    return;
+  }
+
+  /* Lookup the schema */
+  GSettingsSchema *source_schema = g_settings_schema_source_lookup(source, schema, TRUE);
+
+  /* Couldn't find the schema */
+  if (source_schema == NULL) {
+    return;
+  }
+
+  /* Found the schema, make sure we have the key */
+  if (g_settings_schema_has_key(source_schema, key)) {
+    /* Make sure the key is of boolean type */
+    GSettingsSchemaKey *source_key = g_settings_schema_get_key(source_schema, key);
+
+    if (g_variant_type_equal(g_settings_schema_key_get_value_type(source_key), G_VARIANT_TYPE_BOOLEAN)) {
+      /* Set the value */
+      GSettings *settings = g_settings_new(schema);
+      g_settings_set_boolean(settings, key, value);
+      g_object_unref(settings);
+    }
+
+    g_settings_schema_key_unref(source_key);
+  }
+  g_settings_schema_unref(source_schema);
+}
+
+/**
+ * swap_clear_settings_items:
+ * @self: the indicator object
+ *
+ * Swaps the position of the clear and settings items.
+ **/
+static void
+swap_clear_settings_items(IndicatorNotifications *self)
+{
+  g_return_if_fail(IS_INDICATOR_NOTIFICATIONS(self));
+
+  // Pick which widget to move
+  GtkWidget *widget = self->priv->settings_item;
+  if(self->priv->swap_clear_settings)
+    widget = self->priv->clear_item;
+
+  gtk_container_remove(GTK_CONTAINER(self->priv->menu), g_object_ref(widget));
+  gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), widget);
+  g_object_unref(widget);
+}
+
+/**
  * clear_item_activated_cb:
  * @menuitem: the clear menuitem
  * @user_data: the indicator object
@@ -564,11 +779,19 @@ setting_changed_cb(GSettings *settings, gchar *key, gpointer user_data)
     self->priv->hide_indicator = g_settings_get_boolean(settings, NOTIFICATIONS_KEY_HIDE_INDICATOR);
     update_indicator_visibility(self);
   }
+  else if(g_strcmp0(key, NOTIFICATIONS_KEY_DND) == 0) {
+    self->priv->do_not_disturb = g_settings_get_boolean(settings, NOTIFICATIONS_KEY_DND);
+    update_do_not_disturb(self);
+  }
   else if(g_strcmp0(key, NOTIFICATIONS_KEY_CLEAR_MC) == 0) {
     self->priv->clear_on_middle_click = g_settings_get_boolean(self->priv->settings, NOTIFICATIONS_KEY_CLEAR_MC);
   }
-  else if(g_strcmp0(key, NOTIFICATIONS_KEY_BLACKLIST) == 0) {
-    update_blacklist(self);
+  else if(g_strcmp0(key, NOTIFICATIONS_KEY_FILTER_LIST) == 0) {
+    update_filter_list(self);
+  }
+  else if(g_strcmp0(key, NOTIFICATIONS_KEY_SWAP_CLEAR_SETTINGS) == 0) {
+    self->priv->swap_clear_settings = g_settings_get_boolean(self->priv->settings, NOTIFICATIONS_KEY_SWAP_CLEAR_SETTINGS);
+    swap_clear_settings_items(self);
   }
   /* TODO: Trim or extend the notifications list based on "max-items" key
    * (Currently requires a restart) */
@@ -612,19 +835,29 @@ message_received_cb(DBusSpy *spy, Notification *note, gpointer user_data)
   g_return_if_fail(IS_INDICATOR_NOTIFICATIONS(user_data));
   IndicatorNotifications *self = INDICATOR_NOTIFICATIONS(user_data);
 
+  /* Discard notifications if we are hidden */
+  if(self->priv->hide_indicator) {
+    g_object_unref(note);
+    return;
+  }
+
   /* Discard useless notifications */
   if(notification_is_private(note) || notification_is_empty(note)) {
     g_object_unref(note);
     return;
   }
 
-  /* Discard notifications on the blacklist */
-  if(self->priv->blacklist != NULL && g_hash_table_contains(self->priv->blacklist,
+  /* Discard notifications on the filter list */
+  if(self->priv->filter_list != NULL && g_hash_table_contains(self->priv->filter_list,
         notification_get_app_name(note))) {
     g_object_unref(note);
     return;
   }
 
+  /* Save a hint for the appname */
+  update_filter_list_hints(self, note);
+
+  /* Create the menuitem */
   GtkWidget *item = notification_menuitem_new();
   notification_menuitem_set_from_notification(NOTIFICATION_MENUITEM(item), note);
   g_signal_connect(item, NOTIFICATION_MENUITEM_SIGNAL_CLICKED, G_CALLBACK(notification_clicked_cb), self);
diff --git a/src/settings.h b/src/settings.h
index 87e341f..9663c8d 100644
--- a/src/settings.h
+++ b/src/settings.h
@@ -5,10 +5,16 @@
 #ifndef __SETTINGS_H__
 #define __SETTINGS_H__
 
-#define NOTIFICATIONS_SCHEMA             "org.ayatana.indicator.notifications"
-#define NOTIFICATIONS_KEY_BLACKLIST      "blacklist"
-#define NOTIFICATIONS_KEY_CLEAR_MC       "clear-on-middle-click"
-#define NOTIFICATIONS_KEY_HIDE_INDICATOR "hide-indicator"
-#define NOTIFICATIONS_KEY_MAX_ITEMS      "max-items"
+#define NOTIFICATIONS_SCHEMA                  "org.ayatana.indicator.notifications"
+#define NOTIFICATIONS_KEY_FILTER_LIST           "filter-list"
+#define NOTIFICATIONS_KEY_FILTER_LIST_HINTS     "filter-list-hints"
+#define NOTIFICATIONS_KEY_CLEAR_MC            "clear-on-middle-click"
+#define NOTIFICATIONS_KEY_DND                 "do-not-disturb"
+#define NOTIFICATIONS_KEY_HIDE_INDICATOR      "hide-indicator"
+#define NOTIFICATIONS_KEY_MAX_ITEMS           "max-items"
+#define NOTIFICATIONS_KEY_SWAP_CLEAR_SETTINGS "swap-clear-settings"
+
+#define MATE_SCHEMA  "org.mate.NotificationDaemon"
+#define MATE_KEY_DND "do-not-disturb"
 
 #endif