src/plugins/notification/notification_core.c

   1 /* Notification plugin for Claws-Mail
   2  * Copyright (C) 2005-2007 Holger Berndt
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifdef HAVE_CONFIG_H
  19 #  include "config.h"
  20 #  include "claws-features.h"
  21 #endif
  22
  23 #include "folder.h"
  24 #include "folderview.h"
  25 #include "codeconv.h"
  26 #include "gtk/gtkutils.h"
  27
  28 #include "notification_core.h"
  29 #include "notification_plugin.h"
  30 #include "notification_prefs.h"
  31 #include "notification_banner.h"
  32 #include "notification_popup.h"
  33 #include "notification_command.h"
  34 #include "notification_lcdproc.h"
  35 #include "notification_trayicon.h"
  36 #include "notification_indicator.h"
  37
  38 #ifdef HAVE_LIBCANBERRA_GTK
  39 # include <canberra-gtk.h>
  40 #endif
  41
  42 typedef struct {
  43   GSList *collected_msgs;
  44   GSList *folder_items;
  45   gboolean unread_also;
  46   gint max_msgs;
  47   gint num_msgs;
  48 } TraverseCollect;
  49
  50 static gboolean notification_traverse_collect(GNode*, gpointer);
  51 static void     notification_new_unnotified_do_msg(MsgInfo*);
  52 static gboolean notification_traverse_hash_startup(GNode*, gpointer);
  53
  54 static GHashTable *msg_count_hash;
  55 static NotificationMsgCount msg_count;
  56
  57 #ifdef HAVE_LIBCANBERRA_GTK
  58 static gboolean canberra_new_email_is_playing = FALSE;
  59 #endif
  60
  61 static void msg_count_hash_update_func(FolderItem*, gpointer);
  62 static void msg_count_update_from_hash(gpointer, gpointer, gpointer);
  63 static void msg_count_clear(NotificationMsgCount*);
  64 static void msg_count_add(NotificationMsgCount*,NotificationMsgCount*);
  65 static void msg_count_copy(NotificationMsgCount*,NotificationMsgCount*);
  66
  67 void notification_core_global_includes_changed(void)
  68 {
  69 #ifdef NOTIFICATION_BANNER
  70   notification_update_banner();
  71 #endif
  72
  73   if(msg_count_hash) {
  74     g_hash_table_destroy(msg_count_hash);
  75     msg_count_hash = NULL;
  76   }
  77   notification_update_msg_counts(NULL);
  78 }
  79
  80 /* Hide/show main window */
  81 void notification_toggle_hide_show_window(void)
  82 {
  83   MainWindow *mainwin;
  84   if((mainwin = mainwindow_get_mainwindow()) == NULL)
  85     return;
  86
  87   if(gtk_widget_get_visible(GTK_WIDGET(mainwin->window))) {
  88     if((gdk_window_get_state(GTK_WIDGET(mainwin->window)->window)&GDK_WINDOW_STATE_ICONIFIED)
  89        || mainwindow_is_obscured()) {
  90       notification_show_mainwindow(mainwin);
  91     }
  92     else {
  93       main_window_hide(mainwin);
  94     }
  95   }
  96   else {
  97     notification_show_mainwindow(mainwin);
  98   }
  99 }
 100
 101 void notification_update_msg_counts(FolderItem *removed_item)
 102 {
 103   if(!msg_count_hash)
 104     msg_count_hash = g_hash_table_new_full(g_str_hash,g_str_equal,
 105                                            g_free,g_free);
 106
 107   folder_func_to_all_folders(msg_count_hash_update_func, msg_count_hash);
 108
 109   if(removed_item) {
 110     gchar *identifier;
 111     identifier = folder_item_get_identifier(removed_item);
 112     if(identifier) {
 113       g_hash_table_remove(msg_count_hash, identifier);
 114       g_free(identifier);
 115     }
 116   }
 117   msg_count_clear(&msg_count);
 118   g_hash_table_foreach(msg_count_hash, msg_count_update_from_hash, NULL);
 119 #ifdef NOTIFICATION_LCDPROC
 120   notification_update_lcdproc();
 121 #endif
 122 #ifdef NOTIFICATION_TRAYICON
 123   notification_update_trayicon();
 124 #endif
 125 #ifdef NOTIFICATION_INDICATOR
 126   notification_update_indicator();
 127 #endif
 128   notification_update_urgency_hint();
 129 }
 130
 131 static void msg_count_clear(NotificationMsgCount *count)
 132 {
 133   count->new_msgs          = 0;
 134   count->unread_msgs       = 0;
 135   count->unreadmarked_msgs = 0;
 136   count->marked_msgs       = 0;
 137   count->total_msgs        = 0;
 138 }
 139
 140 /* c1 += c2 */
 141 static void msg_count_add(NotificationMsgCount *c1,NotificationMsgCount *c2)
 142 {
 143   c1->new_msgs          += c2->new_msgs;
 144   c1->unread_msgs       += c2->unread_msgs;
 145   c1->unreadmarked_msgs += c2->unreadmarked_msgs;
 146   c1->marked_msgs       += c2->marked_msgs;
 147   c1->total_msgs        += c2->total_msgs;
 148 }
 149
 150 /* c1 = c2 */
 151 static void msg_count_copy(NotificationMsgCount *c1,NotificationMsgCount *c2)
 152 {
 153   c1->new_msgs          = c2->new_msgs;
 154   c1->unread_msgs       = c2->unread_msgs;
 155   c1->unreadmarked_msgs = c2->unreadmarked_msgs;
 156   c1->marked_msgs       = c2->marked_msgs;
 157   c1->total_msgs        = c2->total_msgs;
 158 }
 159
 160 gboolean get_flat_gslist_from_nodes_traverse_func(GNode *node, gpointer data)
 161 {
 162   if(node->data) {
 163     GSList **list = data;
 164     *list = g_slist_prepend(*list, node->data);
 165   }
 166   return FALSE;
 167 }
 168
 169 GSList* get_flat_gslist_from_nodes(GNode *node)
 170 {
 171   GSList *retval = NULL;
 172
 173   g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1, get_flat_gslist_from_nodes_traverse_func, &retval);
 174   return retval;
 175 }
 176
 177 void notification_core_get_msg_count_of_foldername(gchar *foldername, NotificationMsgCount *count)
 178 {
 179   GList *list;
 180   Folder *walk_folder;
 181   Folder *folder = NULL;
 182
 183   for(list = folder_get_list(); list != NULL; list = list->next) {
 184     walk_folder = list->data;
 185     if(strcmp2(foldername, walk_folder->name) == 0) {
 186       folder = walk_folder;
 187       break;
 188     }
 189   }
 190   if(!folder) {
 191     debug_print("Notification plugin: Error: Could not find folder %s\n", foldername);
 192     return;
 193   }
 194
 195   msg_count_clear(count);
 196   notification_core_get_msg_count(get_flat_gslist_from_nodes(folder->node), count);
 197 }
 198
 199 void notification_core_get_msg_count(GSList *folder_list,
 200                                      NotificationMsgCount *count)
 201 {
 202   GSList *walk;
 203
 204   if(!folder_list)
 205     msg_count_copy(count,&msg_count);
 206   else {
 207     msg_count_clear(count);
 208     for(walk = folder_list; walk; walk = walk->next) {
 209       gchar *identifier;
 210       NotificationMsgCount *item_count;
 211       FolderItem *item = (FolderItem*) walk->data;
 212       identifier = folder_item_get_identifier(item);
 213       if(identifier) {
 214         item_count = g_hash_table_lookup(msg_count_hash,identifier);
 215         g_free(identifier);
 216         if(item_count)
 217           msg_count_add(count, item_count);
 218       }
 219     }
 220   }
 221 }
 222
 223 static void msg_count_hash_update_func(FolderItem *item, gpointer data)
 224 {
 225   gchar *identifier;
 226   NotificationMsgCount *count;
 227   GHashTable *hash = data;
 228
 229   if(!notify_include_folder_type(item->folder->klass->type,
 230                                  item->folder->klass->uistr))
 231     return;
 232
 233   identifier = folder_item_get_identifier(item);
 234   if(!identifier)
 235     return;
 236
 237   count = g_hash_table_lookup(hash, identifier);
 238
 239   if(!count) {
 240     count = g_new0(NotificationMsgCount,1);
 241     g_hash_table_insert(hash, identifier, count);
 242   }
 243   else
 244     g_free(identifier);
 245
 246   count->new_msgs          = item->new_msgs;
 247   count->unread_msgs       = item->unread_msgs;
 248   count->unreadmarked_msgs = item->unreadmarked_msgs;
 249   count->marked_msgs       = item->marked_msgs;
 250   count->total_msgs        = item->total_msgs;
 251 }
 252
 253 static void msg_count_update_from_hash(gpointer key, gpointer value,
 254                                        gpointer data)
 255 {
 256   NotificationMsgCount *count = value;
 257   msg_count_add(&msg_count,count);
 258 }
 259
 260
 261 /* Replacement for the post-filtering hook:
 262    Pseudocode by Colin:
 263 hook on FOLDER_ITEM_UPDATE_HOOKLIST
 264  if hook flags & F_ITEM_UPDATE_MSGCOUNT
 265   scan mails (folder_item_get_msg_list)
 266    if MSG_IS_NEW(msginfo->flags) and not in hashtable
 267     notify()
 268     add to hashtable
 269    procmsg_msg_list_free
 270
 271 hook on MSGINFO_UPDATE_HOOKLIST
 272  if hook flags & MSGINFO_UPDATE_FLAGS
 273   if !MSG_IS_NEW(msginfo->flags)
 274    remove from hashtable, it's now useless
 275 */
 276
 277 /* This hash table holds all mails that we already notified about,
 278    and that still are marked as "new". The keys are the msgid's,
 279    the values are just 1's stored in a pointer. */
 280 static GHashTable *notified_hash = NULL;
 281
 282
 283 /* Remove message from the notified_hash if
 284  *  - the message flags changed
 285  *  - the message is not new
 286  *  - the message is in the hash
 287 */
 288 gboolean notification_notified_hash_msginfo_update(MsgInfoUpdate *msg_update)
 289 {
 290   g_return_val_if_fail(msg_update != NULL, FALSE);
 291
 292   if((msg_update->flags & MSGINFO_UPDATE_FLAGS) &&
 293      !MSG_IS_NEW(msg_update->msginfo->flags)) {
 294
 295     MsgInfo *msg;
 296     gchar *msgid;
 297
 298     msg = msg_update->msginfo;
 299     if(msg->msgid)
 300       msgid = msg->msgid;
 301     else {
 302       debug_print("Notification Plugin: Message has no message ID!\n");
 303       msgid = "";
 304     }
 305
 306     g_return_val_if_fail(msg != NULL, FALSE);
 307
 308     if(g_hash_table_lookup(notified_hash, msgid) != NULL) {
 309
 310       debug_print("Notification Plugin: Removing message id %s from hash "
 311                   "table\n", msgid);
 312       g_hash_table_remove(notified_hash, msgid);
 313     }
 314   }
 315   return FALSE;
 316 }
 317
 318 /* On startup, mark all new mails as already notified
 319  * (by including them in the hash) */
 320 void notification_notified_hash_startup_init(void)
 321 {
 322   GList *folder_list, *walk;
 323   Folder *folder;
 324
 325   if(!notified_hash) {
 326     notified_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
 327                                           g_free, NULL);
 328     debug_print("Notification Plugin: Hash table created\n");
 329   }
 330
 331   folder_list = folder_get_list();
 332   for(walk = folder_list; walk != NULL; walk = g_list_next(walk)) {
 333     folder = walk->data;
 334
 335     g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
 336                     notification_traverse_hash_startup, NULL);
 337   }
 338 }
 339
 340 static gboolean notification_traverse_hash_startup(GNode *node, gpointer data)
 341 {
 342   GSList *walk;
 343   GSList *msg_list;
 344   FolderItem *item = (FolderItem*) node->data;
 345   gint new_msgs_left;
 346
 347   if(!(item->new_msgs))
 348     return FALSE;
 349
 350   new_msgs_left = item->new_msgs;
 351   msg_list = folder_item_get_msg_list(item);
 352
 353   for(walk = msg_list; walk; walk = g_slist_next(walk)) {
 354     MsgInfo *msg = (MsgInfo*) walk->data;
 355     if(MSG_IS_NEW(msg->flags)) {
 356       gchar *msgid;
 357
 358       if(msg->msgid)
 359         msgid = msg->msgid;
 360       else {
 361         debug_print("Notification Plugin: Message has no message ID!\n");
 362         msgid = "";
 363       }
 364
 365       /* If the message id is not yet in the hash, add it */
 366       g_hash_table_insert(notified_hash, g_strdup(msgid),
 367                           GINT_TO_POINTER(1));
 368       debug_print("Notification Plugin: Init: Added msg id %s to the hash\n",
 369                   msgid);
 370       /* Decrement left count and check if we're already done */
 371       new_msgs_left--;
 372       if(new_msgs_left == 0)
 373         break;
 374     }
 375   }
 376   procmsg_msg_list_free(msg_list);
 377   return FALSE;
 378 }
 379
 380 void notification_core_free(void)
 381 {
 382   if(notified_hash) {
 383     g_hash_table_destroy(notified_hash);
 384     notified_hash = NULL;
 385   }
 386   if(msg_count_hash) {
 387     g_hash_table_destroy(msg_count_hash);
 388     msg_count_hash = NULL;
 389   }
 390   debug_print("Notification Plugin: Freed internal data\n");
 391 }
 392
 393 void notification_new_unnotified_msgs(FolderItemUpdateData *update_data)
 394 {
 395   GSList *msg_list, *walk;
 396
 397   g_return_if_fail(notified_hash != NULL);
 398
 399   msg_list = folder_item_get_msg_list(update_data->item);
 400
 401   for(walk = msg_list; walk; walk = g_slist_next(walk)) {
 402     MsgInfo *msg;
 403     msg = (MsgInfo*) walk->data;
 404
 405     if(MSG_IS_NEW(msg->flags)) {
 406       gchar *msgid;
 407
 408       if(msg->msgid)
 409         msgid = msg->msgid;
 410       else {
 411         debug_print("Notification Plugin: Message has not message ID!\n");
 412         msgid = "";
 413       }
 414
 415       debug_print("Notification Plugin: Found msg %s, "
 416                   "checking if it is in hash...\n", msgid);
 417       /* Check if message is in hash table */
 418       if(g_hash_table_lookup(notified_hash, msgid) != NULL)
 419         debug_print("yes.\n");
 420       else {
 421         /* Add to hashtable */
 422         g_hash_table_insert(notified_hash, g_strdup(msgid),
 423                             GINT_TO_POINTER(1));
 424         debug_print("no, added to table.\n");
 425
 426         /* Do the notification */
 427         notification_new_unnotified_do_msg(msg);
 428       }
 429
 430     } /* msg is 'new' */
 431   } /* for all messages */
 432   procmsg_msg_list_free(msg_list);
 433 }
 434
 435 #ifdef HAVE_LIBCANBERRA_GTK
 436 static void canberra_finished_cb(ca_context *c, uint32_t id, int error, void *data)
 437 {
 438   canberra_new_email_is_playing = FALSE;
 439 }
 440 #endif
 441
 442 static void notification_new_unnotified_do_msg(MsgInfo *msg)
 443 {
 444 #ifdef NOTIFICATION_POPUP
 445   notification_popup_msg(msg);
 446 #endif
 447 #ifdef NOTIFICATION_COMMAND
 448   notification_command_msg(msg);
 449 #endif
 450 #ifdef NOTIFICATION_TRAYICON
 451   notification_trayicon_msg(msg);
 452 #endif
 453
 454 #ifdef HAVE_LIBCANBERRA_GTK
 455   /* canberra */
 456   if(notify_config.canberra_play_sounds && !canberra_new_email_is_playing) {
 457     ca_proplist *proplist;
 458     ca_proplist_create(&proplist);
 459     ca_proplist_sets(proplist,CA_PROP_EVENT_ID ,"message-new-email");
 460     canberra_new_email_is_playing = TRUE;
 461     ca_context_play_full(ca_gtk_context_get(), 0, proplist, canberra_finished_cb, NULL);
 462     ca_proplist_destroy(proplist);
 463   }
 464 #endif
 465 }
 466
 467 /* If folders is not NULL, then consider only those folder items
 468  * If max_msgs is not 0, stop after collecting msg_msgs messages
 469  */
 470 GSList* notification_collect_msgs(gboolean unread_also, GSList *folder_items,
 471                                   gint max_msgs)
 472 {
 473   GList *folder_list, *walk;
 474   Folder *folder;
 475   TraverseCollect collect_data;
 476
 477   collect_data.unread_also = unread_also;
 478   collect_data.collected_msgs = NULL;
 479   collect_data.folder_items = folder_items;
 480   collect_data.max_msgs = max_msgs;
 481   collect_data.num_msgs = 0;
 482
 483   folder_list = folder_get_list();
 484   for(walk = folder_list; walk != NULL; walk = g_list_next(walk)) {
 485     folder = walk->data;
 486
 487     g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
 488                     notification_traverse_collect, &collect_data);
 489   }
 490   return collect_data.collected_msgs;
 491 }
 492
 493 void notification_collected_msgs_free(GSList *collected_msgs)
 494 {
 495   if(collected_msgs) {
 496     GSList *walk;
 497     for(walk = collected_msgs; walk != NULL; walk = g_slist_next(walk)) {
 498       CollectedMsg *msg = walk->data;
 499       if(msg->from)
 500                                 g_free(msg->from);
 501       if(msg->subject)
 502                                 g_free(msg->subject);
 503       if(msg->folderitem_name)
 504                                 g_free(msg->folderitem_name);
 505                         msg->msginfo = NULL;
 506       g_free(msg);
 507     }
 508     g_slist_free(collected_msgs);
 509   }
 510 }
 511
 512 static gboolean notification_traverse_collect(GNode *node, gpointer data)
 513 {
 514   TraverseCollect *cdata = data;
 515   FolderItem *item = node->data;
 516   gchar *folder_id_cur;
 517
 518   /* Obey global folder type limitations */
 519   if(!notify_include_folder_type(item->folder->klass->type,
 520                                  item->folder->klass->uistr))
 521     return FALSE;
 522
 523   /* If a folder_items list was given, check it first */
 524   if((cdata->folder_items) && (item->path != NULL) &&
 525      ((folder_id_cur  = folder_item_get_identifier(item)) != NULL)) {
 526     FolderItem *list_item;
 527     GSList *walk;
 528     gchar *folder_id_list;
 529     gboolean eq;
 530     gboolean folder_in_list = FALSE;
 531
 532     for(walk = cdata->folder_items; walk != NULL; walk = g_slist_next(walk)) {
 533       list_item = walk->data;
 534       folder_id_list = folder_item_get_identifier(list_item);
 535       eq = !strcmp2(folder_id_list,folder_id_cur);
 536       g_free(folder_id_list);
 537       if(eq) {
 538         folder_in_list = TRUE;
 539         break;
 540       }
 541     }
 542     g_free(folder_id_cur);
 543     if(!folder_in_list)
 544       return FALSE;
 545   }
 546
 547   if(item->new_msgs || (cdata->unread_also && item->unread_msgs)) {
 548     GSList *msg_list = folder_item_get_msg_list(item);
 549     GSList *walk;
 550     for(walk = msg_list; walk != NULL; walk = g_slist_next(walk)) {
 551       MsgInfo *msg_info = walk->data;
 552       CollectedMsg *cmsg;
 553
 554       if((cdata->max_msgs != 0) && (cdata->num_msgs >= cdata->max_msgs))
 555         return FALSE;
 556
 557       if(MSG_IS_NEW(msg_info->flags) ||
 558                                  (MSG_IS_UNREAD(msg_info->flags) && cdata->unread_also)) {
 559
 560                                 cmsg = g_new(CollectedMsg, 1);
 561                                 cmsg->from = g_strdup(msg_info->from ? msg_info->from : "");
 562                                 cmsg->subject = g_strdup(msg_info->subject ? msg_info->subject : "");
 563                                 if(msg_info->folder && msg_info->folder->name)
 564                                         cmsg->folderitem_name = g_strdup(msg_info->folder->path);
 565                                 else
 566                                         cmsg->folderitem_name = g_strdup("");
 567
 568                                 cmsg->msginfo = msg_info;
 569
 570                                 cdata->collected_msgs = g_slist_prepend(cdata->collected_msgs, cmsg);
 571                                 cdata->num_msgs++;
 572       }
 573     }
 574     procmsg_msg_list_free(msg_list);
 575   }
 576
 577   return FALSE;
 578 }
 579
 580 gboolean notify_include_folder_type(FolderType ftype, gchar *uistr)
 581 {
 582   gboolean retval;
 583
 584   retval = FALSE;
 585   switch(ftype) {
 586   case F_MH:
 587   case F_MBOX:
 588   case F_MAILDIR:
 589   case F_IMAP:
 590     if(notify_config.include_mail)
 591       retval = TRUE;
 592     break;
 593   case F_NEWS:
 594     if(notify_config.include_news)
 595       retval = TRUE;
 596     break;
 597   case F_UNKNOWN:
 598     if(uistr == NULL)
 599       retval = FALSE;
 600     else if(!strcmp(uistr, "vCalendar")) {
 601       if(notify_config.include_calendar)
 602         retval = TRUE;
 603     }
 604     else if(!strcmp(uistr, "RSSyl")) {
 605       if(notify_config.include_rss)
 606         retval = TRUE;
 607     }
 608     else
 609       debug_print("Notification Plugin: Unknown folder type %d\n",ftype);
 610     break;
 611   default:
 612     debug_print("Notification Plugin: Unknown folder type %d\n",ftype);
 613   }
 614
 615   return retval;
 616 }
 617
 618 static void fix_folderview_scroll(MainWindow *mainwin)
 619 {
 620         static gboolean fix_done = FALSE;
 621
 622         if (fix_done)
 623                 return;
 624
 625         gtk_widget_queue_resize(mainwin->folderview->ctree);
 626
 627         fix_done = TRUE;
 628 }
 629
 630 void notification_show_mainwindow(MainWindow *mainwin)
 631 {
 632       gtk_window_deiconify(GTK_WINDOW(mainwin->window));
 633       gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mainwin->window), FALSE);
 634       main_window_show(mainwin);
 635       gtk_window_present(GTK_WINDOW(mainwin->window));
 636       fix_folderview_scroll(mainwin);
 637 }
 638
 639 #ifdef HAVE_LIBNOTIFY
 640 #define STR_MAX_LEN 511
 641 /* Returns a newly allocated string which needs to be freed */
 642 gchar* notification_libnotify_sanitize_str(gchar *in)
 643 {
 644   gint i_out;
 645   gchar tmp_str[STR_MAX_LEN+1];
 646
 647   if(in == NULL) return NULL;
 648
 649   i_out = 0;
 650   while(*in) {
 651     if(*in == '<') {
 652       if(i_out+3 >= STR_MAX_LEN) break;
 653       memcpy(&(tmp_str[i_out]),"&lt;",4);
 654       in++; i_out += 4;
 655     }
 656     else if(*in == '>') {
 657       if(i_out+3 >= STR_MAX_LEN) break;
 658       memcpy(&(tmp_str[i_out]),"&gt;",4);
 659       in++; i_out += 4;
 660     }
 661     else if(*in == '&') {
 662       if(i_out+4 >= STR_MAX_LEN) break;
 663       memcpy(&(tmp_str[i_out]),"&amp;",5);
 664       in++; i_out += 5;
 665     }
 666     else {
 667       if(i_out >= STR_MAX_LEN) break;
 668       tmp_str[i_out++] = *in++;
 669     }
 670   }
 671   tmp_str[i_out] = '\0';
 672   return strdup(tmp_str);
 673 }
 674
 675 gchar* notification_validate_utf8_str(gchar *text)
 676 {
 677   gchar *utf8_str = NULL;
 678
 679   if(!g_utf8_validate(text, -1, NULL)) {
 680     debug_print("Notification plugin: String is not valid utf8, "
 681                 "trying to fix it...\n");
 682     /* fix it */
 683     utf8_str = conv_codeset_strdup(text,
 684                                    conv_get_locale_charset_str_no_utf8(),
 685                                    CS_INTERNAL);
 686     /* check if the fix worked */
 687     if(utf8_str == NULL || !g_utf8_validate(utf8_str, -1, NULL)) {
 688       debug_print("Notification plugin: String is still not valid utf8, "
 689                   "sanitizing...\n");
 690       utf8_str = g_malloc(strlen(text)*2+1);
 691       conv_localetodisp(utf8_str, strlen(text)*2+1, text);
 692     }
 693   }
 694   else {
 695     debug_print("Notification plugin: String is valid utf8\n");
 696     utf8_str = g_strdup(text);
 697   }
 698   return utf8_str;
 699 }
 700 #endif