HGKeeper

* Guifications - The end-all, be-all notification framework

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

#if HAVE_CONFIG_H

# include <config.h>

#endif /* HAVE_CONFIG_H */

#include <gflib/gf_feed_manager.h>

#include <gflib/gf_intl.h>

#include <gflib/gf_log.h>

#include <gflib/gf_private.h>

#define GF_FEED_MANAGER_GET_PRIVATE(obj) \

(G_TYPE_INSTANCE_GET_PRIVATE((obj), GF_TYPE_FEED_MANAGER, GfFeedManagerPrivate))

/******************************************************************************

* Enums

*****************************************************************************/

enum {

PROP_ZERO = 0,

PROP_LAST

};

enum {

SIG_REGISTERED,

SIG_UNREGISTERED,

SIG_LAST

};

/******************************************************************************

* Structs

*****************************************************************************/

typedef struct {

GHashTable *feeds;

} GfFeedManagerPrivate;

/******************************************************************************

* Globals

*****************************************************************************/

static GfObjectClass *parent_class = NULL;

static guint signals[SIG_LAST] = { 0, };

/******************************************************************************

* Feed Manager stuff

*****************************************************************************/

static GfFeed *

gf_feed_manager_real_register_feed(GfFeedManager *feed_manager, GfFeed *feed) {

GfFeedManagerPrivate *priv = GF_FEED_MANAGER_GET_PRIVATE(feed_manager);

gchar *name = gf_feed_get_name(feed);

if(!name) {

gf_log_warning("GfFeedManager",

"Failed to register the feed because it does not have "

"a name.\n");

return NULL;

}

if(g_hash_table_lookup(priv->feeds, name)) {

gf_log_warning("GfFeedManager",

"Failed to register the feed '%s' because it is "

"already registered.\n", name);

g_free(name);

return NULL;

}

/* we need a reference for the feed manager */

g_object_ref(feed);

g_hash_table_insert(priv->feeds, g_strdup(name), feed);

/* we create another reference to the feed to work like other feed managers

* that may return a completely separate feed.

g_object_ref(feed);

g_free(name);

return feed;

}

static gboolean

gf_feed_manager_real_unregister_feed(GfFeedManager *feed_manager,

GfFeed *feed)

{

GfFeedManagerPrivate *priv = GF_FEED_MANAGER_GET_PRIVATE(feed_manager);

const gchar *name = gf_feed_get_name(feed);

if(!name) {

gf_log_warning("GfFeedManager",

"Failed to unregister the feed because it does not "

"have a name.\n");

return FALSE;

}

if(!g_hash_table_lookup(priv->feeds, name)) {

gf_log_warning("GfFeedManager",

"Failed to unregister the feed '%s' because it is "

"not registered.\n", feed);

return FALSE;

}

g_hash_table_remove(priv->feeds, name);

return TRUE;

}

static void

gf_feed_manager_real_list_feeds_helper(gpointer k, gpointer v, gpointer d) {

GQueue **queue = (GQueue **)d;

g_queue_push_tail(*queue, v);

}

static GfFeed **

gf_feed_manager_real_list_feeds(const GfFeedManager *feed_manager,

guint *num_feeds)

{

GfFeedManagerPrivate *priv = GF_FEED_MANAGER_GET_PRIVATE(feed_manager);

GfFeed **feeds;

GQueue *queue = g_queue_new();

GList *l;

gint i;

g_hash_table_foreach(priv->feeds,

gf_feed_manager_real_list_feeds_helper,

&queue);

feeds = g_new0(GfFeed *, queue->length + 1);

for(l = queue->head, i = 0; l; l = l->next, i++) {

feeds[i] = g_object_ref(l->data);

}

feeds[i] = NULL;

if(num_feeds)

*num_feeds = queue->length;

g_queue_free(queue);

return feeds;

}

static GfFeed *

gf_feed_manager_real_find_feed(const GfFeedManager *feed_manager,

const gchar *name)

{

GfFeedManagerPrivate *priv = GF_FEED_MANAGER_GET_PRIVATE(feed_manager);

return g_hash_table_lookup(priv->feeds, name);

}

/******************************************************************************

* Object stuff

*****************************************************************************/

static void

gf_feed_manager_finalize(GObject *obj) {

GfFeedManagerPrivate *priv = GF_FEED_MANAGER_GET_PRIVATE(obj);

g_hash_table_destroy(priv->feeds);

G_OBJECT_CLASS(parent_class)->finalize(obj);

}

static void

gf_feed_manager_class_init(GfFeedManagerClass *klass) {

GObjectClass *obj_class = G_OBJECT_CLASS(klass);

parent_class = g_type_class_peek_parent(klass);

g_type_class_add_private(klass, sizeof(GfFeedManagerPrivate));

obj_class->finalize = gf_feed_manager_finalize;

klass->register_feed = gf_feed_manager_real_register_feed;

klass->unregister_feed = gf_feed_manager_real_unregister_feed;

klass->list_feeds = gf_feed_manager_real_list_feeds;

klass->find_feed = gf_feed_manager_real_find_feed;

signals[SIG_REGISTERED] =

g_signal_new("registered-feed",

G_OBJECT_CLASS_TYPE(klass),

G_SIGNAL_RUN_LAST,

G_STRUCT_OFFSET(GfFeedManagerClass, registered_feed),

NULL, NULL,

gf_marshal_VOID__OBJECT,

G_TYPE_NONE,

1, GF_TYPE_FEED);

signals[SIG_UNREGISTERED] =

g_signal_new("unregistered-feed",

G_OBJECT_CLASS_TYPE(klass),

G_SIGNAL_RUN_LAST,

G_STRUCT_OFFSET(GfFeedManagerClass, unregistered_feed),

NULL, NULL,

gf_marshal_VOID__OBJECT,

G_TYPE_NONE,

1, GF_TYPE_FEED);

}

static void

gf_feed_manager_init(GTypeInstance *instance, gpointer g_class) {

GfFeedManagerPrivate *priv = GF_FEED_MANAGER_GET_PRIVATE(instance);

priv->feeds = g_hash_table_new_full(g_str_hash, g_str_equal,

g_free, g_object_unref);

}

/******************************************************************************

* Feed API

*****************************************************************************/

GType

gf_feed_manager_get_type(void) {

static GType type = 0;

if(type == 0) {

static const GTypeInfo info = {

sizeof(GfFeedManagerClass),

NULL,

(GClassInitFunc)gf_feed_manager_class_init,

NULL,

sizeof(GfFeedManager),

gf_feed_manager_init,

};

type = g_type_register_static(GF_TYPE_OBJECT,

"GfFeedManager",

&info, 0);

}

return type;

}

/**

* gf_feed_manager_new:

* Creates a new #GfFeedManager instance.

* Return Value: A new #GfFeedManager instance.

GfFeedManager *

gf_feed_manager_new(void) {

return g_object_new(GF_TYPE_FEED_MANAGER,

NULL);

}

/**

* gf_feed_manager_register_feed:

* @feed_manager : The #GfFeedManager instance.

* @feed : The #GfFeed instance to register.

* Registers @feed into the manager @feed_manager.

* Return Value: TRUE on success, FALSE on failure.

GfFeed *

gf_feed_manager_register_feed(GfFeedManager *feed_manager, GfFeed *feed) {

GfFeedManagerClass *klass;

GfFeed *ret = NULL;

g_return_val_if_fail(GF_IS_FEED_MANAGER(feed_manager), FALSE);

g_return_val_if_fail(GF_IS_FEED(feed), FALSE);

klass = GF_FEED_MANAGER_GET_CLASS(feed_manager);

g_return_val_if_fail(GF_IS_FEED_MANAGER_CLASS(klass), FALSE);

if(klass->register_feed)

ret = klass->register_feed(feed_manager, feed);

if(GF_IS_FEED(ret)) {

/* this is private api that is only to be used by GfFeedManager, and

* none of it's children.

gf_feed_set_feed_manager(feed, feed_manager);

g_signal_emit_by_name(feed_manager, "registered-feed", feed);

}

return ret;

}

/**

* gf_feed_manager_unregister_feed:

* @feed_manager : The #GfFeedManager instance.

* @feed : The #GfFeed instance to unregister.

* Unregisters @feed from the manager @feed_manager.

* Return Value: TRUE on success, FALSE on failure.

gboolean

gf_feed_manager_unregister_feed(GfFeedManager *feed_manager, GfFeed *feed) {

GfFeedManagerClass *klass;

gboolean ret = FALSE;

g_return_val_if_fail(GF_IS_FEED_MANAGER(feed_manager), FALSE);

g_return_val_if_fail(GF_IS_FEED(feed), FALSE);

klass = GF_FEED_MANAGER_GET_CLASS(feed_manager);

g_return_val_if_fail(GF_IS_FEED_MANAGER_CLASS(klass), FALSE);

if(klass->unregister_feed)

ret = klass->unregister_feed(feed_manager, feed);

if(ret) {

/* this is private api that is only to be used by GfFeedManager, and

* none of it's children.

gf_feed_set_feed_manager(feed, NULL);

g_signal_emit_by_name(feed_manager, "unregistered-feed", feed);

}

return ret;

}

/**

* gf_feed_manager_list_feeds:

* @feed_manager : The #GfFeedManager instance.

* @num_feeds : Return address for the number of feeds.

* Gets a list of all #GfFeed's in @feed_manager.

* Return Value: A newly allocated array of #GfFeed's.

GfFeed **

gf_feed_manager_list_feeds(const GfFeedManager *feed_manager,

guint *num_feeds)

{

GfFeedManagerClass *klass;

g_return_val_if_fail(GF_IS_FEED_MANAGER(feed_manager), NULL);

klass = GF_FEED_MANAGER_GET_CLASS(feed_manager);

g_return_val_if_fail(GF_IS_FEED_MANAGER_CLASS(klass), NULL);

if(klass->list_feeds)

return klass->list_feeds(feed_manager, num_feeds);

return NULL;

}

/**

* gf_feed_manager_find_feed:

* @feed_manager : The #GfFeedManager instance.

* @name : The name of the feed to find.

* Finds a #GfFeed in @feed_manager.

* Return Value: The #GfFeed on success, or NULL if the feed could not be

* found.

GfFeed *

gf_feed_manager_find_feed(const GfFeedManager *feed_manager,

const gchar *name)

{

GfFeedManagerClass *klass;

g_return_val_if_fail(GF_IS_FEED_MANAGER(feed_manager), NULL);

g_return_val_if_fail(name, NULL);

klass = GF_FEED_MANAGER_GET_CLASS(feed_manager);

g_return_val_if_fail(GF_IS_FEED_MANAGER_CLASS(klass), NULL);

if(klass->find_feed)

return klass->find_feed(feed_manager, name);

return NULL;

}

/**

* gf_feed_manager_emit_event:

* @feed_manager : The #GfFeedManager instance.

* @feed : The #GfFeed instance.

* @event : The #GfEvent instance.

* @event_info : The #GfEventInfo instance.

* Emits @event for @feed registered in @feed_manager, using the information

* from @event_info.

void

gf_feed_manager_emit_event(GfFeedManager *feed_manager, const GfFeed *feed,

const GfEvent *event, const GfEventInfo *event_info)

{

GfFeedManagerPrivate *priv = NULL;

GfFeed *lookup;

const gchar *feed_name, *event_name;

g_return_if_fail(GF_IS_FEED_MANAGER(feed_manager));

g_return_if_fail(GF_IS_FEED(feed));

g_return_if_fail(GF_IS_EVENT(event));

g_return_if_fail(GF_IS_EVENT_INFO(event_info));

priv = GF_FEED_MANAGER_GET_PRIVATE(feed_manager);

feed_name = gf_feed_get_name(feed);

event_name = gf_event_get_name(event);

lookup = g_hash_table_lookup(priv->feeds, feed_name);

if(!GF_IS_FEED(lookup)) {

gf_log_warning("GfFeedManager",

"Feed %s is not registered in this manager.\n",

feed_name);

return;

}

if(feed != lookup) {

gf_log_warning("GfFeedManager",

"Feed %s does not match the registered feed of the "

" same name.\n",

feed_name);

return;

}

#warning finish me

}

grim/guifications3