notify.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include "notify.h"
#include "logging2.h"
#include "memory.h"
#include "notify_type.h"
#include "observer.h"
#include "queue.h"
 
static const char *NotifyTypeNames[] = {
  "NT_ALL",     "NT_ACCOUNT",  "NT_ALIAS",   "NT_ALTERN", "NT_ATTACH",
  "NT_BINDING", "NT_COLOR",    "NT_COMMAND", "NT_CONFIG", "NT_CONTEXT",
  "NT_EMAIL",   "NT_ENVELOPE", "NT_GLOBAL",  "NT_HEADER", "NT_INDEX",
  "NT_MAILBOX", "NT_MENU",     "NT_PAGER",   "NT_RESIZE", "NT_SCORE",
  "NT_SUBJRX",  "NT_TIMEOUT",  "NT_WINDOW",
};
 
struct Notify
{
  struct Notify *parent;         
  struct ObserverList observers; 
};
 
struct Notify *notify_new(void)
{
  struct Notify *notify = mutt_mem_calloc(1, sizeof(*notify));
 
  STAILQ_INIT(&notify->observers);
 
  return notify;
}
 
void notify_free(struct Notify **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct Notify *notify = *ptr;
  // NOTIFY observers
 
  notify_observer_remove_all(notify);
 
  FREE(ptr);
}
 
void notify_set_parent(struct Notify *notify, struct Notify *parent)
{
  if (!notify)
    return;
 
  notify->parent = parent;
}
 
static bool send(struct Notify *source, struct Notify *current,
                 enum NotifyType event_type, int event_subtype, void *event_data)
{
  if (!source || !current)
    return false;
 
  mutt_debug(LL_NOTIFY, "send: %d, %p\n", event_type, event_data);
  struct ObserverNode *np = NULL;
  STAILQ_FOREACH(np, &current->observers, entries)
  {
    struct Observer *o = np->observer;
    if (!o)
      continue;
 
    if ((o->type == NT_ALL) || (event_type == o->type))
    {
      struct NotifyCallback nc = { current, event_type, event_subtype,
                                   event_data, o->global_data };
      if (o->callback(&nc) < 0)
      {
        mutt_debug(LL_DEBUG1, "failed to send notification: %s/%d, global %p, event %p\n",
                   NotifyTypeNames[event_type], event_subtype, o->global_data, event_data);
      }
    }
  }
 
  if (current->parent)
    return send(source, current->parent, event_type, event_subtype, event_data);
 
  // Garbage collection time
  struct ObserverNode *tmp = NULL;
  STAILQ_FOREACH_SAFE(np, &current->observers, entries, tmp)
  {
    if (np->observer)
      continue;
 
    STAILQ_REMOVE(&current->observers, np, ObserverNode, entries);
    FREE(&np);
  }
 
  return true;
}
 
bool notify_send(struct Notify *notify, enum NotifyType event_type,
                 int event_subtype, void *event_data)
{
  mutt_debug(LL_NOTIFY, "sending: %s/%d\n", NotifyTypeNames[event_type], event_subtype);
  return send(notify, notify, event_type, event_subtype, event_data);
}
 
bool notify_observer_add(struct Notify *notify, enum NotifyType type,
                         observer_t callback, void *global_data)
{
  if (!notify || !callback)
    return false;
 
  struct ObserverNode *np = NULL;
  STAILQ_FOREACH(np, &notify->observers, entries)
  {
    if (!np->observer)
      continue; // LCOV_EXCL_LINE
 
    if ((np->observer->callback == callback) && (np->observer->global_data == global_data))
      return true;
  }
 
  struct Observer *o = mutt_mem_calloc(1, sizeof(*o));
  o->type = type;
  o->callback = callback;
  o->global_data = global_data;
 
  np = mutt_mem_calloc(1, sizeof(*np));
  np->observer = o;
  STAILQ_INSERT_HEAD(&notify->observers, np, entries);
 
  return true;
}
 
bool notify_observer_remove(struct Notify *notify, const observer_t callback,
                            const void *global_data)
{
  if (!notify || !callback)
    return false;
 
  struct ObserverNode *np = NULL;
  STAILQ_FOREACH(np, &notify->observers, entries)
  {
    if (!np->observer)
      continue; // LCOV_EXCL_LINE
 
    if ((np->observer->callback == callback) && (np->observer->global_data == global_data))
    {
      FREE(&np->observer);
      return true;
    }
  }
 
  return false;
}
 
void notify_observer_remove_all(struct Notify *notify)
{
  if (!notify)
    return;
 
  struct ObserverNode *np = NULL;
  struct ObserverNode *tmp = NULL;
  STAILQ_FOREACH_SAFE(np, &notify->observers, entries, tmp)
  {
    STAILQ_REMOVE(&notify->observers, np, ObserverNode, entries);
    FREE(&np->observer);
    FREE(&np);
  }
}