attic/aaina/libaaina/aaina-library.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
   2
   3 /*
   4  * Copyright (C) 2007 OpenedHand Ltd
   5  *
   6  * Author: Matthew Allum  <mallum@openedhand.com>
   7  */
   8
   9 #include "aaina-library.h"
  10 #include <string.h>
  11
  12 G_DEFINE_TYPE (AainaLibrary, aaina_library, G_TYPE_OBJECT);
  13
  14 #define LIBRARY_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), AAINA_TYPE_LIBRARY, AainaLibraryPrivate))
  15
  16 typedef struct _AainaLibraryPrivate AainaLibraryPrivate;
  17
  18 enum
  19 {
  20         REORDERED,
  21         PHOTO_CHANGED,
  22         PHOTO_ADDED,
  23         FILTER,
  24         LAST_SIGNAL
  25 };
  26
  27 static guint _library_signals[LAST_SIGNAL] = { 0 };
  28
  29 struct _AainaLibraryPrivate
  30 {
  31         AainaFilterRowFunc      filter;
  32         gpointer                filter_data;
  33         AainaCompareRowFunc     sort;
  34         gpointer                sort_data;
  35         EggSequence             *photos;
  36   GList             *list;
  37   guint              size;
  38   guint              max_photos;
  39   gboolean           pending;
  40 };
  41
  42 static void
  43 aaina_library_get_property (GObject *object, guint property_id,
  44                              GValue *value, GParamSpec *pspec)
  45 {
  46         switch (property_id) {
  47                 default:
  48                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id,
  49                                                            pspec);
  50         }
  51 }
  52
  53 static void
  54 aaina_library_set_property (GObject *object, guint property_id,
  55                                   const GValue *value, GParamSpec *pspec)
  56 {
  57         switch (property_id) {
  58                 default:
  59                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id,
  60                                                            pspec);
  61         }
  62 }
  63
  64 static void
  65 aaina_library_dispose (GObject *object)
  66 {
  67         if (G_OBJECT_CLASS (aaina_library_parent_class)->dispose)
  68                 G_OBJECT_CLASS (aaina_library_parent_class)->dispose (object);
  69 }
  70
  71 static void
  72 aaina_library_finalize (GObject *object)
  73 {
  74         G_OBJECT_CLASS (aaina_library_parent_class)->finalize (object);
  75 }
  76
  77 static void
  78 aaina_library_class_init (AainaLibraryClass *klass)
  79 {
  80         GObjectClass *object_class = G_OBJECT_CLASS (klass);
  81
  82         g_type_class_add_private (klass, sizeof (AainaLibraryPrivate));
  83
  84         object_class->get_property = aaina_library_get_property;
  85         object_class->set_property = aaina_library_set_property;
  86         object_class->dispose = aaina_library_dispose;
  87         object_class->finalize = aaina_library_finalize;
  88
  89         _library_signals[REORDERED] =
  90                 g_signal_new ("photos-reordered",
  91                               G_OBJECT_CLASS_TYPE (object_class),
  92                               G_SIGNAL_RUN_FIRST,
  93                               G_STRUCT_OFFSET (AainaLibraryClass, reordered),
  94                               NULL, NULL,
  95                               g_cclosure_marshal_VOID__VOID,
  96                               G_TYPE_NONE, 0);
  97
  98         _library_signals[FILTER] =
  99                 g_signal_new ("filter-changed",
 100                              G_OBJECT_CLASS_TYPE (object_class),
 101                              G_SIGNAL_RUN_FIRST,
 102                              G_STRUCT_OFFSET (AainaLibraryClass, filter_change),
 103                              NULL, NULL,
 104                              g_cclosure_marshal_VOID__VOID,
 105                              G_TYPE_NONE, 0);
 106
 107         _library_signals[PHOTO_CHANGED] =
 108                 g_signal_new ("photo-changed",
 109                              G_OBJECT_CLASS_TYPE (object_class),
 110                              G_SIGNAL_RUN_FIRST,
 111                              G_STRUCT_OFFSET (AainaLibraryClass, photo_change),
 112                              NULL, NULL,
 113                              g_cclosure_marshal_VOID__OBJECT,
 114                              G_TYPE_NONE, 1, AAINA_TYPE_PHOTO);
 115
 116         _library_signals[PHOTO_ADDED] =
 117                 g_signal_new ("photo-added",
 118                              G_OBJECT_CLASS_TYPE (object_class),
 119                              G_SIGNAL_RUN_FIRST,
 120                              G_STRUCT_OFFSET (AainaLibraryClass, photo_added),
 121                              NULL, NULL,
 122                              g_cclosure_marshal_VOID__OBJECT,
 123                              G_TYPE_NONE, 1, AAINA_TYPE_PHOTO);
 124
 125 }
 126
 127 static void
 128 aaina_library_init (AainaLibrary *self)
 129 {
 130         AainaLibraryPrivate *priv = LIBRARY_PRIVATE(self);
 131
 132         priv->photos = egg_sequence_new (NULL);
 133   priv->list = NULL;
 134   priv->size = 0;
 135   priv->max_photos = 100;
 136   priv->pending = FALSE;
 137 }
 138
 139 static gboolean
 140 check_filter (AainaLibrary *library, EggSequenceIter *iter)
 141 {
 142         AainaLibraryPrivate *priv = LIBRARY_PRIVATE(library);
 143         gboolean res;
 144
 145         if (priv->filter == NULL)
 146                 return TRUE;
 147
 148         res = priv->filter(library, (AainaPhoto*)egg_sequence_get (iter),
 149                            priv->filter_data);
 150         return res;
 151 }
 152
 153 gboolean
 154 aaina_library_get_pending (AainaLibrary *library)
 155 {
 156   AainaLibraryPrivate *priv;
 157
 158   g_return_val_if_fail (AAINA_IS_LIBRARY (library), FALSE);
 159   priv = LIBRARY_PRIVATE (library);
 160
 161   return priv->pending;
 162 }
 163
 164 void
 165 aaina_library_set_pending (AainaLibrary *library, gboolean pending)
 166 {
 167   AainaLibraryPrivate *priv;
 168
 169   g_return_if_fail (AAINA_IS_LIBRARY (library));
 170   priv = LIBRARY_PRIVATE (library);
 171
 172   priv->pending = pending;
 173 }
 174
 175 gboolean
 176 aaina_library_is_full (AainaLibrary *library)
 177 {
 178   AainaLibraryPrivate *priv;
 179
 180   g_return_val_if_fail (AAINA_IS_LIBRARY (library), FALSE);
 181   priv = LIBRARY_PRIVATE (library);
 182
 183   if (priv->size >= priv->max_photos)
 184   {
 185     return TRUE;
 186   }
 187
 188   return FALSE;
 189 }
 190
 191 void
 192 aaina_library_set_max (AainaLibrary *library, gint max_photos)
 193 {
 194   AainaLibraryPrivate *priv;
 195
 196   g_return_if_fail (AAINA_IS_LIBRARY (library));
 197   priv = LIBRARY_PRIVATE (library);
 198
 199   priv->max_photos = max_photos;
 200 }
 201
 202 guint
 203 aaina_library_photo_count (AainaLibrary *library)
 204 {
 205         AainaLibraryPrivate *priv = LIBRARY_PRIVATE(library);
 206         EggSequenceIter     *iter;
 207         gint                 n = 0;
 208
 209   return priv->size;
 210   return g_list_length (priv->list);
 211
 212         if (priv->filter == NULL)
 213                 return egg_sequence_get_length (priv->photos);
 214
 215         iter = egg_sequence_get_begin_iter (priv->photos);
 216
 217         while (!egg_sequence_iter_is_end (iter)) {
 218                 if (check_filter (library, iter))
 219                         n++;
 220                 iter = egg_sequence_iter_next (iter);
 221         }
 222
 223         return n;
 224 }
 225
 226 AainaPhoto*
 227 aaina_library_get_photo (AainaLibrary *library, gint index)
 228 {
 229         AainaLibraryPrivate *priv = LIBRARY_PRIVATE(library);
 230         EggSequenceIter     *iter;
 231         gint                 n = 0;
 232
 233         return (AainaPhoto*)g_list_nth_data (priv->list, index);
 234
 235   if (priv->filter == NULL)
 236                 return (AainaPhoto*)egg_sequence_get
 237                              (egg_sequence_get_iter_at_pos (priv->photos, index));
 238
 239         iter = egg_sequence_get_begin_iter (priv->photos);
 240
 241         while (!egg_sequence_iter_is_end (iter)) {
 242                 if (check_filter (library, iter)) {
 243                         if (n == index)
 244                                 return (AainaPhoto*)egg_sequence_get (iter);
 245                         n++;
 246                 }
 247                 iter = egg_sequence_iter_next (iter);
 248         }
 249
 250         return NULL;
 251 }
 252
 253 static void
 254 on_photo_changed (GObject *obj, GParamSpec   *arg1,
 255                                    gpointer      data)
 256 {
 257         return;
 258         AainaLibrary        *library = AAINA_LIBRARY(data);
 259         AainaLibraryPrivate *priv;
 260
 261         priv = LIBRARY_PRIVATE(library);
 262
 263         /* thumbnail changing does not effect ordering */
 264         if (!strcmp(g_param_spec_get_name(arg1), "thumbnail"))
 265                 return;
 266
 267         if (priv->sort) {
 268                 egg_sequence_sort (priv->photos,
 269                                 (GCompareDataFunc)priv->sort, priv->sort_data);
 270                 g_signal_emit (library, _library_signals[REORDERED], 0);
 271         }
 272
 273         g_signal_emit (library, _library_signals[PHOTO_CHANGED], 0,
 274                                                         AAINA_PHOTO(obj));
 275 }
 276
 277 void
 278 aaina_library_append_photo (AainaLibrary *library, AainaPhoto *photo)
 279 {
 280         AainaLibraryPrivate *priv = LIBRARY_PRIVATE(library);
 281         EggSequenceIter     *iter;
 282
 283         g_signal_connect (photo, "notify", G_CALLBACK (on_photo_changed), library);
 284
 285         /*
 286
 287         if (priv->sort)
 288                 iter = egg_sequence_insert_sorted (priv->photos, (gpointer)photo,
 289                                                   (GCompareDataFunc)priv->sort,
 290                                                    priv->sort_data);
 291         else
 292                 iter = egg_sequence_append (priv->photos, (gpointer)photo);
 293   */
 294         priv->list = g_list_append (priv->list, photo);
 295   priv->size++;
 296   g_signal_emit (library, _library_signals[PHOTO_ADDED], 0, photo);
 297 }
 298
 299 void
 300 aaina_library_remove_photo (AainaLibrary *library, const AainaPhoto *photo)
 301 {
 302   AainaLibraryPrivate *priv = LIBRARY_PRIVATE(library);
 303
 304   priv->list = g_list_remove (priv->list, (gconstpointer)photo);
 305   priv->size--;
 306 }
 307
 308
 309 void
 310 aaina_library_foreach (AainaLibrary      *library,
 311                         AainaForeachRowFunc   func,
 312                         gpointer           data)
 313 {
 314         AainaLibraryPrivate *priv = LIBRARY_PRIVATE(library);
 315         EggSequenceIter     *iter;
 316   GList *l;
 317
 318   for (l = priv->list; l != NULL; l = l->next)
 319   {
 320     if (AAINA_IS_PHOTO (l->data))
 321       func (library, (AainaPhoto*)l->data, data );
 322   }
 323   return;
 324 /*
 325   iter = egg_sequence_get_begin_iter (priv->photos);
 326         while (!egg_sequence_iter_is_end (iter)) {
 327                 if (check_filter (library, iter))
 328                         if (func (library,
 329                                   (AainaPhoto*)egg_sequence_get (iter, data) == FALSE)
 330                                 return;
 331
 332                 iter = egg_sequence_iter_next (iter);
 333         }
 334   */
 335 }
 336
 337 void
 338 aaina_library_set_sort_func (AainaLibrary     *library,
 339                               AainaCompareRowFunc  func,
 340                               gpointer          userdata)
 341 {
 342         AainaLibraryPrivate *priv = LIBRARY_PRIVATE(library);
 343
 344         priv->sort      = func;
 345         priv->sort_data = userdata;
 346
 347         if (func) {
 348                 egg_sequence_sort (priv->photos, (GCompareDataFunc)func, userdata);
 349                 g_signal_emit (library, _library_signals[REORDERED], 0);
 350         }
 351 }
 352
 353 void
 354 aaina_library_set_filter (AainaLibrary    *library,
 355                            AainaFilterRowFunc  filter,
 356                            gpointer         data)
 357 {
 358         AainaLibraryPrivate *priv = LIBRARY_PRIVATE(library);
 359         AainaFilterRowFunc      prev_filter;
 360
 361         prev_filter = priv->filter;
 362
 363         priv->filter      = filter;
 364         priv->filter_data = data;
 365
 366         if (prev_filter != priv->filter)
 367                 g_signal_emit (library, _library_signals[FILTER], 0);
 368 }
 369
 370 AainaLibrary*
 371 aaina_library_new ()
 372 {
 373         return g_object_new (AAINA_TYPE_LIBRARY, NULL);
 374 }
 375