src/ui/gui/psppire-case-array.c

   1 /*
   2     PSPPIRE --- A Graphical User Interface for PSPP
   3     Copyright (C) 2004  Free Software Foundation
   4     Written by John Darrington
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19     02110-1301, USA. */
  20
  21
  22 #include <string.h>
  23 #include <stdlib.h>
  24
  25 #include "psppire-object.h"
  26 #include "psppire-case-array.h"
  27
  28 #include <gtksheet/gtkextra-marshal.h>
  29
  30 #include <data/case.h>
  31
  32 /* --- prototypes --- */
  33 static void psppire_case_array_class_init       (PsppireCaseArrayClass  *class);
  34 static void psppire_case_array_init     (PsppireCaseArray       *case_array);
  35 static void psppire_case_array_finalize (GObject                *object);
  36
  37
  38 /* --- variables --- */
  39 static GObjectClass     *parent_class = NULL;
  40
  41 enum  {CASE_CHANGED,
  42        CASE_INSERTED,
  43        CASES_DELETED,
  44        n_SIGNALS};
  45
  46 static guint signal[n_SIGNALS];
  47
  48
  49 /* --- functions --- */
  50 /**
  51  * psppire_case_array_get_type:
  52  * @returns: the type ID for accelerator groups.
  53  */
  54 GType
  55 psppire_case_array_get_type (void)
  56 {
  57   static GType object_type = 0;
  58
  59   if (!object_type)
  60     {
  61       static const GTypeInfo object_info = {
  62         sizeof (PsppireCaseArrayClass),
  63         (GBaseInitFunc) NULL,
  64         (GBaseFinalizeFunc) NULL,
  65         (GClassInitFunc) psppire_case_array_class_init,
  66         NULL,   /* class_finalize */
  67         NULL,   /* class_data */
  68         sizeof (PsppireCaseArray),
  69         0,      /* n_preallocs */
  70         (GInstanceInitFunc) psppire_case_array_init,
  71       };
  72
  73       object_type = g_type_register_static (G_TYPE_PSPPIRE_OBJECT, "PsppireCaseArray",
  74                                             &object_info, 0);
  75     }
  76
  77   return object_type;
  78 }
  79
  80
  81 static void
  82 psppire_case_array_class_init (PsppireCaseArrayClass *class)
  83 {
  84   GObjectClass *object_class = G_OBJECT_CLASS (class);
  85
  86   parent_class = g_type_class_peek_parent (class);
  87
  88   object_class->finalize = psppire_case_array_finalize;
  89
  90   signal[CASE_CHANGED] =
  91     g_signal_new ("case_changed",
  92                   G_TYPE_FROM_CLASS(class),
  93                   G_SIGNAL_RUN_FIRST,
  94                   0,
  95                   NULL, NULL,
  96                   g_cclosure_marshal_VOID__INT,
  97                   G_TYPE_NONE,
  98                   1,
  99                   G_TYPE_INT);
 100
 101
 102   signal[CASE_INSERTED] =
 103     g_signal_new ("case_inserted",
 104                   G_TYPE_FROM_CLASS(class),
 105                   G_SIGNAL_RUN_FIRST,
 106                   0,
 107                   NULL, NULL,
 108                   g_cclosure_marshal_VOID__INT,
 109                   G_TYPE_NONE,
 110                   1,
 111                   G_TYPE_INT);
 112
 113
 114   signal[CASES_DELETED] =
 115     g_signal_new ("cases_deleted",
 116                   G_TYPE_FROM_CLASS(class),
 117                   G_SIGNAL_RUN_FIRST,
 118                   0,
 119                   NULL, NULL,
 120                   gtkextra_VOID__INT_INT,
 121                   G_TYPE_NONE,
 122                   2,
 123                   G_TYPE_INT,
 124                   G_TYPE_INT);
 125 }
 126
 127 static void
 128 psppire_case_array_finalize (GObject *object)
 129 {
 130   PsppireCaseArray *ca = PSPPIRE_CASE_ARRAY (object);
 131
 132   gint i;
 133   for (i = 0 ; i < ca->size; ++i )
 134     case_destroy(&ca->cases[i]);
 135
 136   g_free (ca->cases);
 137
 138   G_OBJECT_CLASS (parent_class)->finalize (object);
 139 }
 140
 141 static void
 142 psppire_case_array_init (PsppireCaseArray *ca)
 143 {
 144   ca->cases = 0;
 145   ca->size = 0;
 146 }
 147
 148 /**
 149  * psppire_case_array_new:
 150  * @returns: a new #PsppireCaseArray object
 151  *
 152  * Creates a new #PsppireCaseArray.
 153  */
 154 PsppireCaseArray*
 155 psppire_case_array_new (gint capacity, gint width)
 156 {
 157   PsppireCaseArray *ca = g_object_new (G_TYPE_PSPPIRE_CASE_ARRAY, NULL);
 158
 159   ca->capacity = capacity;
 160   ca->width = width;
 161
 162   ca->cases = g_new0(struct ccase, capacity);
 163
 164   return ca;
 165 }
 166
 167
 168 void
 169 psppire_case_array_resize(PsppireCaseArray *ca,  gint new_size)
 170 {
 171   gint c;
 172
 173   for (c = 0 ; c < ca->size ; ++c )
 174     case_resize(&ca->cases[c], ca->width, new_size);
 175
 176   ca->width = new_size;
 177 }
 178
 179 /* FIXME: add_case and insert_case need to be merged/refactored */
 180 gboolean
 181 psppire_case_array_add_case(PsppireCaseArray *ca,
 182                          psppire_case_array_fill_case_func fill_case_func,
 183                          gpointer aux)
 184 {
 185   g_return_val_if_fail(ca->size < ca->capacity, FALSE);
 186
 187   case_create(&ca->cases[ca->size], ca->width);
 188
 189   if ( !fill_case_func(&ca->cases[ca->size], aux))
 190     return FALSE;
 191
 192   ca->size++;
 193
 194   g_signal_emit(ca, signal[CASE_INSERTED], 0, ca->size - 1);
 195
 196   return TRUE;
 197 }
 198
 199
 200 gboolean
 201 psppire_case_array_iterate_case(PsppireCaseArray *ca,
 202                          psppire_case_array_use_case_func use_case_func,
 203                          gpointer aux)
 204 {
 205   gint i;
 206   g_return_val_if_fail(ca->size < ca->capacity, FALSE);
 207
 208   for (i = 0 ; i < ca->size ; ++i )
 209     {
 210       if ( !use_case_func(&ca->cases[i], aux))
 211         return FALSE;
 212     }
 213
 214   return TRUE;
 215 }
 216
 217
 218 void
 219 psppire_case_array_insert_case(PsppireCaseArray *ca, gint posn)
 220 {
 221   g_return_if_fail(posn >= 0);
 222   g_return_if_fail(posn <= ca->size);
 223
 224   g_assert(ca->size + 1 <= ca->capacity);
 225
 226   gint i;
 227
 228   for(i = ca->size; i > posn ; --i)
 229       case_move(&ca->cases[i], &ca->cases[i - 1]);
 230
 231   case_create(&ca->cases[posn], ca->width);
 232
 233   ca->size++;
 234   g_signal_emit(ca, signal[CASE_INSERTED], 0, posn);
 235 }
 236
 237 void
 238 psppire_case_array_delete_cases(PsppireCaseArray *ca, gint first, gint n_cases)
 239 {
 240   g_return_if_fail(n_cases > 0);
 241   g_return_if_fail(first >= 0);
 242   g_return_if_fail(first + n_cases < ca->size);
 243
 244   gint i;
 245
 246   /* FIXME: Is this right ?? */
 247   for ( i = first; i < first + n_cases ; ++i )
 248     case_destroy(&ca->cases[i]);
 249
 250   for ( ; i < ca->size; ++i )
 251     case_move(&ca->cases[i - n_cases], &ca->cases[i]);
 252
 253   ca->size -= n_cases;
 254   g_signal_emit(ca, signal[CASES_DELETED], 0, first, n_cases);
 255 }
 256
 257
 258 gint
 259 psppire_case_array_get_n_cases(const PsppireCaseArray *ca)
 260 {
 261   return ca->size;
 262 }
 263
 264 /* Clears the contents of CA */
 265 void
 266 psppire_case_array_clear(PsppireCaseArray *ca)
 267 {
 268   gint c;
 269   for (c = 0 ; c < ca->size ; ++c )
 270     case_destroy(&ca->cases[c]);
 271
 272   ca->size = 0;
 273
 274   g_signal_emit(ca, signal[CASES_DELETED], 0, 0, c);
 275 }
 276
 277 /* Return the IDXth value from case C */
 278 const union value *
 279 psppire_case_array_get_value(const PsppireCaseArray *ca, gint c, gint idx)
 280 {
 281   g_return_val_if_fail(c < ca->size, NULL);
 282
 283   return case_data(&ca->cases[c], idx);
 284 }
 285
 286
 287 /* Set the IDXth value of case C using FF and DATA */
 288 void
 289 psppire_case_array_set_value(PsppireCaseArray *ca, gint c, gint idx,
 290                           value_fill_func_t ff,
 291                           gpointer data)
 292 {
 293   g_return_if_fail(c < ca->size);
 294
 295   struct ccase *cc = &ca->cases[c];
 296
 297   union value *val = case_data_rw(cc, idx);
 298
 299   gboolean changed = ff(val, data);
 300
 301   case_unshare(cc);
 302
 303   if ( changed )
 304     g_signal_emit(ca, signal[CASE_CHANGED], 0, c);
 305
 306 }