~ubuntu-branches/ubuntu/precise/folks/precise-201306070638

/* has-presence.c generated by valac 0.11.2.25-30b2-dirty, the Vala compiler

 * generated from has-presence.vala, do not modify */

 

/*

 * Copyright (C) 2010 Collabora Ltd.

 *

 * This library 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.

 *

 * This library 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 this library.  If not, see <http://www.gnu.org/licenses/>.

 *

 * Authors:

 *       Travis Reitter <travis.reitter@collabora.co.uk>

 */

 

#include <glib.h>

#include <glib-object.h>

#include <stdlib.h>

#include <string.h>

 

 

#define FOLKS_TYPE_PRESENCE_TYPE (folks_presence_type_get_type ())

 

#define FOLKS_TYPE_HAS_PRESENCE (folks_has_presence_get_type ())

#define FOLKS_HAS_PRESENCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOLKS_TYPE_HAS_PRESENCE, FolksHasPresence))

#define FOLKS_IS_HAS_PRESENCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOLKS_TYPE_HAS_PRESENCE))

#define FOLKS_HAS_PRESENCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), FOLKS_TYPE_HAS_PRESENCE, FolksHasPresenceIface))

 

typedef struct _FolksHasPresence FolksHasPresence;

typedef struct _FolksHasPresenceIface FolksHasPresenceIface;

 

typedef enum  {

        FOLKS_PRESENCE_TYPE_UNSET,

        FOLKS_PRESENCE_TYPE_OFFLINE,

        FOLKS_PRESENCE_TYPE_AVAILABLE,

        FOLKS_PRESENCE_TYPE_AWAY,

        FOLKS_PRESENCE_TYPE_EXTENDED_AWAY,

        FOLKS_PRESENCE_TYPE_HIDDEN,

        FOLKS_PRESENCE_TYPE_BUSY,

        FOLKS_PRESENCE_TYPE_UNKNOWN,

        FOLKS_PRESENCE_TYPE_ERROR

} FolksPresenceType;

 

struct _FolksHasPresenceIface {

        GTypeInterface parent_iface;

        FolksPresenceType (*get_presence_type) (FolksHasPresence* self);

        void (*set_presence_type) (FolksHasPresence* self, FolksPresenceType value);

        const gchar* (*get_presence_message) (FolksHasPresence* self);

        void (*set_presence_message) (FolksHasPresence* self, const gchar* value);

};

 

 

 

GType folks_presence_type_get_type (void) G_GNUC_CONST;

GType folks_has_presence_get_type (void) G_GNUC_CONST;

static guint folks_has_presence_type_availability (FolksPresenceType type);

gint folks_has_presence_typecmp (FolksPresenceType type_a, FolksPresenceType type_b);

gboolean folks_has_presence_is_online (FolksHasPresence* self);

FolksPresenceType folks_has_presence_get_presence_type (FolksHasPresence* self);

void folks_has_presence_set_presence_type (FolksHasPresence* self, FolksPresenceType value);

const gchar* folks_has_presence_get_presence_message (FolksHasPresence* self);

void folks_has_presence_set_presence_message (FolksHasPresence* self, const gchar* value);

 

 

/**

 * The possible presence states an object implementing {@link HasPresence} could

 * be in.

 *

 * These closely follow the

 * [[http://telepathy.freedesktop.org/spec/Connection_Interface_Simple_Presence.html#Connection_Presence_Type|SimplePresence]]

 * interface in the Telepathy specification.

 */

GType folks_presence_type_get_type (void) {

        static volatile gsize folks_presence_type_type_id__volatile = 0;

        if (g_once_init_enter (&folks_presence_type_type_id__volatile)) {

                static const GEnumValue values[] = {{FOLKS_PRESENCE_TYPE_UNSET, "FOLKS_PRESENCE_TYPE_UNSET", "unset"}, {FOLKS_PRESENCE_TYPE_OFFLINE, "FOLKS_PRESENCE_TYPE_OFFLINE", "offline"}, {FOLKS_PRESENCE_TYPE_AVAILABLE, "FOLKS_PRESENCE_TYPE_AVAILABLE", "available"}, {FOLKS_PRESENCE_TYPE_AWAY, "FOLKS_PRESENCE_TYPE_AWAY", "away"}, {FOLKS_PRESENCE_TYPE_EXTENDED_AWAY, "FOLKS_PRESENCE_TYPE_EXTENDED_AWAY", "extended-away"}, {FOLKS_PRESENCE_TYPE_HIDDEN, "FOLKS_PRESENCE_TYPE_HIDDEN", "hidden"}, {FOLKS_PRESENCE_TYPE_BUSY, "FOLKS_PRESENCE_TYPE_BUSY", "busy"}, {FOLKS_PRESENCE_TYPE_UNKNOWN, "FOLKS_PRESENCE_TYPE_UNKNOWN", "unknown"}, {FOLKS_PRESENCE_TYPE_ERROR, "FOLKS_PRESENCE_TYPE_ERROR", "error"}, {0, NULL, NULL}};

                GType folks_presence_type_type_id;

                folks_presence_type_type_id = g_enum_register_static ("FolksPresenceType", values);

                g_once_init_leave (&folks_presence_type_type_id__volatile, folks_presence_type_type_id);

        }

        return folks_presence_type_type_id__volatile;

}

 

 

static guint folks_has_presence_type_availability (FolksPresenceType type) {

        guint result = 0U;

        switch (type) {

                case FOLKS_PRESENCE_TYPE_UNSET:

                {

                        result = (guint) 0;

                        return result;

                }

                case FOLKS_PRESENCE_TYPE_UNKNOWN:

                {

                        result = (guint) 1;

                        return result;

                }

                case FOLKS_PRESENCE_TYPE_ERROR:

                {

                        result = (guint) 2;

                        return result;

                }

                case FOLKS_PRESENCE_TYPE_OFFLINE:

                {

                        result = (guint) 3;

                        return result;

                }

                case FOLKS_PRESENCE_TYPE_HIDDEN:

                {

                        result = (guint) 4;

                        return result;

                }

                case FOLKS_PRESENCE_TYPE_EXTENDED_AWAY:

                {

                        result = (guint) 5;

                        return result;

                }

                case FOLKS_PRESENCE_TYPE_AWAY:

                {

                        result = (guint) 6;

                        return result;

                }

                case FOLKS_PRESENCE_TYPE_BUSY:

                {

                        result = (guint) 7;

                        return result;

                }

                case FOLKS_PRESENCE_TYPE_AVAILABLE:

                {

                        result = (guint) 8;

                        return result;

                }

                default:

                {

                        result = (guint) 1;

                        return result;

                }

        }

}

 

 

/**

   * Compare two {@link PresenceType}s.

   *

   * `0` will be returned if the types are equal, a positive number will be

   * returned if `type_a` is more available than `type_b`, and a negative

   * number will be returned if the opposite is true.

   *

   * @param type_a the first {@link PresenceType} to compare

   * @param type_b the second {@link PresenceType} to compare

   * @return a number representing the similarity of the two types

   * @since 0.1.11

   */

gint folks_has_presence_typecmp (FolksPresenceType type_a, FolksPresenceType type_b) {

        gint result = 0;

        guint _tmp0_;

        guint _tmp1_;

        _tmp0_ = folks_has_presence_type_availability (type_a);

        _tmp1_ = folks_has_presence_type_availability (type_b);

        result = ((gint) _tmp0_) - ((gint) _tmp1_);

        return result;

}

 

 

/**

   * Whether the contact is online.

   *

   * This will be `true` if the contact's presence type is higher than

   * {@link PresenceType.OFFLINE}, as determined by {@link HasPresence.typecmp}.

   *

   * @return `true` if the contact is online, `false` otherwise

   */

gboolean folks_has_presence_is_online (FolksHasPresence* self) {

        gboolean result = FALSE;

        FolksPresenceType _tmp0_;

        gint _tmp1_;

        _tmp0_ = folks_has_presence_get_presence_type (self);

        _tmp1_ = folks_has_presence_typecmp (_tmp0_, FOLKS_PRESENCE_TYPE_OFFLINE);

        result = _tmp1_ > 0;

        return result;

}

 

 

FolksPresenceType folks_has_presence_get_presence_type (FolksHasPresence* self) {

        return FOLKS_HAS_PRESENCE_GET_INTERFACE (self)->get_presence_type (self);

}

 

 

void folks_has_presence_set_presence_type (FolksHasPresence* self, FolksPresenceType value) {

        FOLKS_HAS_PRESENCE_GET_INTERFACE (self)->set_presence_type (self, value);

}

 

 

const gchar* folks_has_presence_get_presence_message (FolksHasPresence* self) {

        return FOLKS_HAS_PRESENCE_GET_INTERFACE (self)->get_presence_message (self);

}

 

 

void folks_has_presence_set_presence_message (FolksHasPresence* self, const gchar* value) {

        FOLKS_HAS_PRESENCE_GET_INTERFACE (self)->set_presence_message (self, value);

}

 

 

static void folks_has_presence_base_init (FolksHasPresenceIface * iface) {

        static gboolean initialized = FALSE;

        if (!initialized) {

                initialized = TRUE;

                /**

                   * The contact's presence type.

                   *

                   * Each contact can have one and only one presence type at any one time,

                   * representing their availability for communication. The default presence

                   * type is {@link PresenceType.UNSET}.

                   */

                g_object_interface_install_property (iface, g_param_spec_enum ("presence-type", "presence-type", "presence-type", FOLKS_TYPE_PRESENCE_TYPE, FOLKS_PRESENCE_TYPE_UNSET, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));

                /**

                   * The contact's presence message.

                   *

                   * This is a short message written by the contact to add detail to their

                   * presence type ({@link Folks.HasPresence.presence_type}). If the contact

                   * hasn't set a message, it will be an empty string.

                   */

                g_object_interface_install_property (iface, g_param_spec_string ("presence-message", "presence-message", "presence-message", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));

        }

}

 

 

/**

 * Interface exposing a {@link Persona}'s or {@link Individual}'s presence;

 * their current availability, such as for chatting.

 *

 * If the {@link Backend} providing the {@link Persona} doesn't support

 * presence, the {@link Persona}'s `presence_type` will be set to

 * {@link PresenceType.UNSET} and their `presence_message` will be an empty

 * string.

 */

GType folks_has_presence_get_type (void) {

        static volatile gsize folks_has_presence_type_id__volatile = 0;

        if (g_once_init_enter (&folks_has_presence_type_id__volatile)) {

                static const GTypeInfo g_define_type_info = { sizeof (FolksHasPresenceIface), (GBaseInitFunc) folks_has_presence_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };

                GType folks_has_presence_type_id;

                folks_has_presence_type_id = g_type_register_static (G_TYPE_INTERFACE, "FolksHasPresence", &g_define_type_info, 0);

                g_type_interface_add_prerequisite (folks_has_presence_type_id, G_TYPE_OBJECT);

                g_once_init_leave (&folks_has_presence_type_id__volatile, folks_has_presence_type_id);

        }

        return folks_has_presence_type_id__volatile;

}