tags.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "tags.h"
 
struct HashTable *TagTransforms = NULL; 
struct HashTable *TagFormats = NULL; 
 
void tag_free(struct Tag **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct Tag *tag = *ptr;
  FREE(&tag->name);
  FREE(&tag->transformed);
 
  FREE(ptr);
}
 
struct Tag *tag_new(void)
{
  return MUTT_MEM_CALLOC(1, struct Tag);
}
 
void driver_tags_getter(struct TagList *tl, bool show_hidden, bool show_transformed,
                        const char *filter, struct Buffer *tags)
{
  if (!tl)
    return;
 
  struct Tag *tag = NULL;
  STAILQ_FOREACH(tag, tl, entries)
  {
    if (filter && !mutt_str_equal(tag->name, filter))
      continue;
    if (show_hidden || !tag->hidden)
    {
      if (show_transformed && tag->transformed)
        buf_join_str(tags, tag->transformed, ' ');
      else
        buf_join_str(tags, tag->name, ' ');
    }
  }
}
 
void driver_tags_add(struct TagList *tl, char *new_tag)
{
  char *new_tag_transformed = mutt_hash_find(TagTransforms, new_tag);
 
  struct Tag *tag = tag_new();
  tag->name = new_tag;
  tag->hidden = false;
  tag->transformed = mutt_str_dup(new_tag_transformed);
 
  /* filter out hidden tags */
  const struct Slist *c_hidden_tags = cs_subset_slist(NeoMutt->sub, "hidden_tags");
  if (c_hidden_tags)
    if (mutt_list_find(&c_hidden_tags->head, new_tag))
      tag->hidden = true;
 
  STAILQ_INSERT_TAIL(tl, tag, entries);
}
 
void driver_tags_free(struct TagList *tl)
{
  if (!tl)
    return;
 
  struct Tag *tag = STAILQ_FIRST(tl);
  struct Tag *next = NULL;
  while (tag)
  {
    next = STAILQ_NEXT(tag, entries);
    tag_free(&tag);
    tag = next;
  }
  STAILQ_INIT(tl);
}
 
void driver_tags_get_transformed(struct TagList *tl, struct Buffer *tags)
{
  driver_tags_getter(tl, false, true, NULL, tags);
}
 
void driver_tags_get(struct TagList *tl, struct Buffer *tags)
{
  driver_tags_getter(tl, false, false, NULL, tags);
}
 
void driver_tags_get_with_hidden(struct TagList *tl, struct Buffer *tags)
{
  driver_tags_getter(tl, true, false, NULL, tags);
}
 
void driver_tags_get_transformed_for(struct TagList *tl, const char *name, struct Buffer *tags)
{
  driver_tags_getter(tl, true, true, name, tags);
}
 
bool driver_tags_replace(struct TagList *tl, const char *tags)
{
  if (!tl)
    return false;
 
  driver_tags_free(tl);
 
  if (tags)
  {
    struct ListHead hsplit = STAILQ_HEAD_INITIALIZER(hsplit);
    mutt_list_str_split(&hsplit, tags, ' ');
    struct ListNode *np = NULL;
    STAILQ_FOREACH(np, &hsplit, entries)
    {
      driver_tags_add(tl, np->data);
    }
    mutt_list_clear(&hsplit);
  }
  return true;
}
 
static void tags_deleter(int type, void *obj, intptr_t data)
{
  FREE(&obj);
}
 
void driver_tags_init(void)
{
  TagTransforms = mutt_hash_new(64, MUTT_HASH_STRCASECMP | MUTT_HASH_STRDUP_KEYS);
  mutt_hash_set_destructor(TagTransforms, tags_deleter, 0);
 
  TagFormats = mutt_hash_new(64, MUTT_HASH_STRDUP_KEYS);
  mutt_hash_set_destructor(TagFormats, tags_deleter, 0);
}
 
void driver_tags_cleanup(void)
{
  mutt_hash_free(&TagFormats);
  mutt_hash_free(&TagTransforms);
}