libpurple/countingnode.c

   1 /*
   2  * purple
   3  *
   4  * Purple is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  *
  22  */
  23 #include "internal.h"
  24 #include "glibcompat.h"
  25 #include "countingnode.h"
  26
  27 #define PURPLE_COUNTING_NODE_GET_PRIVATE(obj) \
  28         (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_COUNTING_NODE, PurpleCountingNodePrivate))
  29
  30 typedef struct _PurpleCountingNodePrivate  PurpleCountingNodePrivate;
  31
  32 /* Private data of a counting node */
  33 struct _PurpleCountingNodePrivate {
  34         int totalsize;    /* The number of children under this node            */
  35         int currentsize;  /* The number of children under this node
  36                              corresponding to online accounts                  */
  37         int onlinecount;  /* The number of children under this contact who are
  38                              currently online                                  */
  39 };
  40
  41 /* Counting node property enums */
  42 enum
  43 {
  44         PROP_0,
  45         PROP_TOTAL_SIZE,
  46         PROP_CURRENT_SIZE,
  47         PROP_ONLINE_COUNT,
  48         PROP_LAST
  49 };
  50
  51 static GParamSpec *properties[PROP_LAST];
  52
  53 /******************************************************************************
  54  * API
  55  *****************************************************************************/
  56 int
  57 purple_counting_node_get_total_size(PurpleCountingNode *counter)
  58 {
  59         PurpleCountingNodePrivate *priv = PURPLE_COUNTING_NODE_GET_PRIVATE(counter);
  60
  61         g_return_val_if_fail(priv != NULL, -1);
  62
  63         return priv->totalsize;
  64 }
  65
  66 int
  67 purple_counting_node_get_current_size(PurpleCountingNode *counter)
  68 {
  69         PurpleCountingNodePrivate *priv = PURPLE_COUNTING_NODE_GET_PRIVATE(counter);
  70
  71         g_return_val_if_fail(priv != NULL, -1);
  72
  73         return priv->currentsize;
  74 }
  75
  76 int
  77 purple_counting_node_get_online_count(PurpleCountingNode *counter)
  78 {
  79         PurpleCountingNodePrivate *priv = PURPLE_COUNTING_NODE_GET_PRIVATE(counter);
  80
  81         g_return_val_if_fail(priv != NULL, -1);
  82
  83         return priv->onlinecount;
  84 }
  85
  86 void
  87 purple_counting_node_change_total_size(PurpleCountingNode *counter, int delta)
  88 {
  89         PurpleCountingNodePrivate *priv = PURPLE_COUNTING_NODE_GET_PRIVATE(counter);
  90
  91         g_return_if_fail(priv != NULL);
  92
  93         purple_counting_node_set_total_size(counter, priv->totalsize + delta);
  94 }
  95
  96 void
  97 purple_counting_node_change_current_size(PurpleCountingNode *counter, int delta)
  98 {
  99         PurpleCountingNodePrivate *priv = PURPLE_COUNTING_NODE_GET_PRIVATE(counter);
 100
 101         g_return_if_fail(priv != NULL);
 102
 103         purple_counting_node_set_current_size(counter, priv->currentsize + delta);
 104 }
 105
 106 void
 107 purple_counting_node_change_online_count(PurpleCountingNode *counter, int delta)
 108 {
 109         PurpleCountingNodePrivate *priv = PURPLE_COUNTING_NODE_GET_PRIVATE(counter);
 110
 111         g_return_if_fail(priv != NULL);
 112
 113         purple_counting_node_set_online_count(counter, priv->onlinecount + delta);
 114 }
 115
 116 void
 117 purple_counting_node_set_total_size(PurpleCountingNode *counter, int totalsize)
 118 {
 119         PurpleCountingNodePrivate *priv = PURPLE_COUNTING_NODE_GET_PRIVATE(counter);
 120
 121         g_return_if_fail(priv != NULL);
 122
 123         priv->totalsize = totalsize;
 124
 125         g_object_notify_by_pspec(G_OBJECT(counter), properties[PROP_TOTAL_SIZE]);
 126 }
 127
 128 void
 129 purple_counting_node_set_current_size(PurpleCountingNode *counter, int currentsize)
 130 {
 131         PurpleCountingNodePrivate *priv = PURPLE_COUNTING_NODE_GET_PRIVATE(counter);
 132
 133         g_return_if_fail(priv != NULL);
 134
 135         priv->currentsize = currentsize;
 136
 137         g_object_notify_by_pspec(G_OBJECT(counter), properties[PROP_CURRENT_SIZE]);
 138 }
 139
 140 void
 141 purple_counting_node_set_online_count(PurpleCountingNode *counter, int onlinecount)
 142 {
 143         PurpleCountingNodePrivate *priv = PURPLE_COUNTING_NODE_GET_PRIVATE(counter);
 144
 145         g_return_if_fail(priv != NULL);
 146
 147         priv->onlinecount = onlinecount;
 148
 149         g_object_notify_by_pspec(G_OBJECT(counter), properties[PROP_ONLINE_COUNT]);
 150 }
 151
 152 /**************************************************************************
 153  * GObject Stuff
 154  **************************************************************************/
 155 /* Set method for GObject properties */
 156 static void
 157 purple_counting_node_set_property(GObject *obj, guint param_id, const GValue *value,
 158                 GParamSpec *pspec)
 159 {
 160         PurpleCountingNode *node = PURPLE_COUNTING_NODE(obj);
 161
 162         switch (param_id) {
 163                 case PROP_TOTAL_SIZE:
 164                         purple_counting_node_set_total_size(node, g_value_get_int(value));
 165                         break;
 166                 case PROP_CURRENT_SIZE:
 167                         purple_counting_node_set_current_size(node, g_value_get_int(value));
 168                         break;
 169                 case PROP_ONLINE_COUNT:
 170                         purple_counting_node_set_online_count(node, g_value_get_int(value));
 171                         break;
 172                 default:
 173                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
 174                         break;
 175         }
 176 }
 177
 178 /* Get method for GObject properties */
 179 static void
 180 purple_counting_node_get_property(GObject *obj, guint param_id, GValue *value,
 181                 GParamSpec *pspec)
 182 {
 183         PurpleCountingNode *node = PURPLE_COUNTING_NODE(obj);
 184
 185         switch (param_id) {
 186                 case PROP_TOTAL_SIZE:
 187                         g_value_set_int(value, purple_counting_node_get_total_size(node));
 188                         break;
 189                 case PROP_CURRENT_SIZE:
 190                         g_value_set_int(value, purple_counting_node_get_current_size(node));
 191                         break;
 192                 case PROP_ONLINE_COUNT:
 193                         g_value_set_int(value, purple_counting_node_get_online_count(node));
 194                         break;
 195                 default:
 196                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
 197                         break;
 198         }
 199 }
 200
 201 /* Class initializer function */
 202 static void
 203 purple_counting_node_class_init(PurpleCountingNodeClass *klass)
 204 {
 205         GObjectClass *obj_class = G_OBJECT_CLASS(klass);
 206
 207         /* Setup properties */
 208         obj_class->get_property = purple_counting_node_get_property;
 209         obj_class->set_property = purple_counting_node_set_property;
 210
 211         g_type_class_add_private(klass, sizeof(PurpleCountingNodePrivate));
 212
 213         properties[PROP_TOTAL_SIZE] = g_param_spec_int(
 214                 "total-size",
 215                 "Total size",
 216                 "The number of children under this node.",
 217                 G_MININT, G_MAXINT, 0,
 218                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS
 219         );
 220
 221         properties[PROP_CURRENT_SIZE] = g_param_spec_int(
 222                 "current-size",
 223                 "Current size",
 224                 "The number of children with online accounts.",
 225                 G_MININT, G_MAXINT, 0,
 226                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS
 227         );
 228
 229         properties[PROP_ONLINE_COUNT] = g_param_spec_int(
 230                 "online-count",
 231                 "Online count",
 232                 "The number of children that are online.",
 233                 G_MININT, G_MAXINT, 0,
 234                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS
 235         );
 236
 237         g_object_class_install_properties(obj_class, PROP_LAST, properties);
 238 }
 239
 240 GType
 241 purple_counting_node_get_type(void)
 242 {
 243         static GType type = 0;
 244
 245         if(type == 0) {
 246                 static const GTypeInfo info = {
 247                         sizeof(PurpleCountingNodeClass),
 248                         NULL,
 249                         NULL,
 250                         (GClassInitFunc)purple_counting_node_class_init,
 251                         NULL,
 252                         NULL,
 253                         sizeof(PurpleCountingNode),
 254                         0,
 255                         NULL,
 256                         NULL,
 257                 };
 258
 259                 type = g_type_register_static(PURPLE_TYPE_BLIST_NODE,
 260                                 "PurpleCountingNode",
 261                                 &info, G_TYPE_FLAG_ABSTRACT);
 262         }
 263
 264         return type;
 265 }