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
 180 /* Append a case to the case array.  If FILL_CASE_FUNC is not NULL,
 181  * then use it to populate the case */
 182 inline gboolean
 183 psppire_case_array_append_case(PsppireCaseArray *ca,
 184                          psppire_case_array_fill_case_func fill_case_func,
 185                          gpointer aux)
 186 {
 187   return psppire_case_array_insert_case(ca, ca->size, fill_case_func, aux);
 188 }
 189
 190
 191 gboolean
 192 psppire_case_array_iterate_case(PsppireCaseArray *ca,
 193                          psppire_case_array_use_case_func use_case_func,
 194                          gpointer aux)
 195 {
 196   gint i;
 197   g_return_val_if_fail(ca->size < ca->capacity, FALSE);
 198
 199   for (i = 0 ; i < ca->size ; ++i )
 200     {
 201       if ( !use_case_func(&ca->cases[i], aux))
 202         return FALSE;
 203     }
 204
 205   return TRUE;
 206 }
 207
 208
 209 /* Insert a new case before case POSN.
 210  * If FILL_CASE_FUNC is not NULL, then use it to populate the new case */
 211 gboolean
 212 psppire_case_array_insert_case(PsppireCaseArray *ca, gint posn,
 213                                psppire_case_array_fill_case_func fill_case_func,
 214                                gpointer aux)
 215
 216 {
 217   gint i;
 218
 219   g_return_val_if_fail(posn >= 0, FALSE);
 220   g_return_val_if_fail(posn <= ca->size, FALSE);
 221
 222   g_return_val_if_fail(ca->size < ca->capacity, FALSE);
 223
 224   for(i = ca->size; i > posn ; --i)
 225       case_move(&ca->cases[i], &ca->cases[i - 1]);
 226
 227   case_create(&ca->cases[posn], ca->width);
 228
 229   if ( fill_case_func && !fill_case_func(&ca->cases[posn], aux))
 230     return FALSE;
 231
 232   ca->size++;
 233   g_signal_emit(ca, signal[CASE_INSERTED], 0, posn);
 234
 235   return TRUE;
 236 }
 237
 238 void
 239 psppire_case_array_delete_cases(PsppireCaseArray *ca, gint first, gint n_cases)
 240 {
 241   gint i;
 242
 243   g_return_if_fail(n_cases > 0);
 244   g_return_if_fail(first >= 0);
 245   g_return_if_fail(first + n_cases < ca->size);
 246
 247
 248   /* FIXME: Is this right ?? */
 249   for ( i = first; i < first + n_cases ; ++i )
 250     case_destroy(&ca->cases[i]);
 251
 252   for ( ; i < ca->size; ++i )
 253     case_move(&ca->cases[i - n_cases], &ca->cases[i]);
 254
 255   ca->size -= n_cases;
 256   g_signal_emit(ca, signal[CASES_DELETED], 0, first, n_cases);
 257 }
 258
 259
 260 gint
 261 psppire_case_array_get_n_cases(const PsppireCaseArray *ca)
 262 {
 263   return ca->size;
 264 }
 265
 266 /* Clears the contents of CA */
 267 void
 268 psppire_case_array_clear(PsppireCaseArray *ca)
 269 {
 270   gint c;
 271   for (c = 0 ; c < ca->size ; ++c )
 272     case_destroy(&ca->cases[c]);
 273
 274   ca->size = 0;
 275
 276   g_signal_emit(ca, signal[CASES_DELETED], 0, 0, c);
 277 }
 278
 279 /* Return the IDXth value from case C */
 280 const union value *
 281 psppire_case_array_get_value(const PsppireCaseArray *ca, gint c, gint idx)
 282 {
 283   g_return_val_if_fail(c < ca->size, NULL);
 284
 285   return case_data(&ca->cases[c], idx);
 286 }
 287
 288
 289 /* Set the IDXth value of case C using FF and DATA */
 290 void
 291 psppire_case_array_set_value(PsppireCaseArray *ca, gint c, gint idx,
 292                           value_fill_func_t ff,
 293                           gpointer data)
 294 {
 295   struct ccase *cc ;
 296   union value *val ;
 297   gboolean changed ;
 298
 299   g_return_if_fail(c < ca->size);
 300
 301   cc = &ca->cases[c];
 302
 303   val = case_data_rw(cc, idx);
 304
 305   changed = ff(val, data);
 306
 307   case_unshare(cc);
 308
 309   if ( changed )
 310     g_signal_emit(ca, signal[CASE_CHANGED], 0, c);
 311
 312 }