/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ /* * GData Client * Copyright (C) Philip Withnall 2010 * * GData Client is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * GData Client 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with GData Client. If not, see . */ /** * SECTION:gdata-youtube-category * @short_description: YouTube category element * @stability: Stable * @include: gdata/services/youtube/gdata-youtube-category.h * * #GDataYouTubeCategory represents the YouTube-specific customizations to #GDataCategory. For more information, * see the * online documentation. * * Since: 0.7.0 */ #include #include #include #include "gdata-youtube-category.h" #include "gdata-parsable.h" #include "gdata-parser.h" static void gdata_youtube_category_finalize (GObject *object); static void gdata_youtube_category_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); static gboolean parse_xml (GDataParsable *parsable, xmlDoc *doc, xmlNode *node, gpointer user_data, GError **error); static void get_namespaces (GDataParsable *parsable, GHashTable *namespaces); struct _GDataYouTubeCategoryPrivate { gboolean assignable; gchar **browsable_regions; /*gboolean deprecated; --- "Categories that are neither assignable or browsable are deprecated and are identified as such using the * tag." */ }; enum { PROP_IS_ASSIGNABLE = 1, PROP_IS_DEPRECATED }; G_DEFINE_TYPE (GDataYouTubeCategory, gdata_youtube_category, GDATA_TYPE_CATEGORY) static void gdata_youtube_category_class_init (GDataYouTubeCategoryClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GDataParsableClass *parsable_class = GDATA_PARSABLE_CLASS (klass); g_type_class_add_private (klass, sizeof (GDataYouTubeCategoryPrivate)); gobject_class->get_property = gdata_youtube_category_get_property; gobject_class->finalize = gdata_youtube_category_finalize; parsable_class->parse_xml = parse_xml; parsable_class->get_namespaces = get_namespaces; /** * GDataYouTubeCategory:is-assignable: * * Whether new videos can be added to the category. * * Since: 0.7.0 */ g_object_class_install_property (gobject_class, PROP_IS_ASSIGNABLE, g_param_spec_boolean ("is-assignable", "Assignable?", "Whether new videos can be added to the category.", FALSE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); /** * GDataYouTubeCategory:is-deprecated: * * Whether the category is deprecated. * * Since: 0.7.0 */ g_object_class_install_property (gobject_class, PROP_IS_DEPRECATED, g_param_spec_boolean ("is-deprecated", "Deprecated?", "Whether the category is deprecated.", TRUE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); } static void gdata_youtube_category_init (GDataYouTubeCategory *self) { self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GDATA_TYPE_YOUTUBE_CATEGORY, GDataYouTubeCategoryPrivate); } static void gdata_youtube_category_finalize (GObject *object) { GDataYouTubeCategoryPrivate *priv = GDATA_YOUTUBE_CATEGORY (object)->priv; g_strfreev (priv->browsable_regions); /* Chain up to the parent class */ G_OBJECT_CLASS (gdata_youtube_category_parent_class)->finalize (object); } static void gdata_youtube_category_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GDataYouTubeCategoryPrivate *priv = GDATA_YOUTUBE_CATEGORY (object)->priv; switch (property_id) { case PROP_IS_ASSIGNABLE: g_value_set_boolean (value, priv->assignable); break; case PROP_IS_DEPRECATED: g_value_set_boolean (value, (priv->assignable == FALSE && priv->browsable_regions == NULL) ? TRUE : FALSE); break; default: /* We don't have any other property... */ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } static gboolean parse_xml (GDataParsable *parsable, xmlDoc *doc, xmlNode *node, gpointer user_data, GError **error) { GDataYouTubeCategory *self = GDATA_YOUTUBE_CATEGORY (parsable); if (gdata_parser_is_namespace (node, "http://gdata.youtube.com/schemas/2007") == TRUE) { if (xmlStrcmp (node->name, (xmlChar*) "assignable") == 0) { /* yt:assignable */ self->priv->assignable = TRUE; } else if (xmlStrcmp (node->name, (xmlChar*) "deprecated") == 0) { /* yt:deprecated */ self->priv->assignable = FALSE; g_strfreev (self->priv->browsable_regions); self->priv->browsable_regions = NULL; } else if (xmlStrcmp (node->name, (xmlChar*) "browsable") == 0) { /* yt:browsable */ xmlChar *regions; regions = xmlGetProp (node, (xmlChar*) "regions"); if (regions == NULL) return gdata_parser_error_required_property_missing (node, "regions", error); self->priv->browsable_regions = g_strsplit ((gchar*) regions, " ", -1); xmlFree (regions); } else { return GDATA_PARSABLE_CLASS (gdata_youtube_category_parent_class)->parse_xml (parsable, doc, node, user_data, error); } } else { return GDATA_PARSABLE_CLASS (gdata_youtube_category_parent_class)->parse_xml (parsable, doc, node, user_data, error); } return TRUE; } static void get_namespaces (GDataParsable *parsable, GHashTable *namespaces) { /* Chain up to the parent class */ GDATA_PARSABLE_CLASS (gdata_youtube_category_parent_class)->get_namespaces (parsable, namespaces); g_hash_table_insert (namespaces, (gchar*) "youtube", (gchar*) "http://gdata.youtube.com/schemas/2007"); } /** * gdata_youtube_category_is_assignable: * @self: a #GDataYouTubeCategory * * Gets the #GDataYouTubeCategory:is-assignable property. * * Return value: whether new videos can be assigned to the category * * Since: 0.7.0 */ gboolean gdata_youtube_category_is_assignable (GDataYouTubeCategory *self) { g_return_val_if_fail (GDATA_IS_YOUTUBE_CATEGORY (self), FALSE); return self->priv->assignable; } /** * gdata_youtube_category_is_browsable: * @self: a #GDataYouTubeCategory * @region: a two-letter region ID * * Returns whether the category is browsable in the given @region. The list of supported region IDs is * available online. * * Return value: whether the category is browsable in @region * * Since: 0.7.0 */ gboolean gdata_youtube_category_is_browsable (GDataYouTubeCategory *self, const gchar *region) { g_return_val_if_fail (GDATA_IS_YOUTUBE_CATEGORY (self), FALSE); g_return_val_if_fail (region != NULL && *region != '\0', FALSE); if (self->priv->browsable_regions != NULL) { guint i; for (i = 0; self->priv->browsable_regions[i] != NULL; i++) { if (strcmp (self->priv->browsable_regions[i], region) == 0) return TRUE; } } return FALSE; } /** * gdata_youtube_category_is_deprecated: * @self: a #GDataYouTubeCategory * * Gets the #GDataYouTubeCategory:is-deprecated property. * * Return value: whether the category is deprecated * * Since: 0.7.0 */ gboolean gdata_youtube_category_is_deprecated (GDataYouTubeCategory *self) { g_return_val_if_fail (GDATA_IS_YOUTUBE_CATEGORY (self), TRUE); return (self->priv->assignable == FALSE && self->priv->browsable_regions == NULL) ? TRUE : FALSE; }