7e16087eb93ae7bfe2057d72fdc49cb3d9e48136
[pspp-builds.git] / src / ui / gui / psppire-case-file.c
1 /* 
2     PSPPIRE --- A Graphical User Interface for PSPP
3     Copyright (C) 2006  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 #include <config.h>
22 #include <string.h>
23 #include <stdlib.h>
24
25 #include "psppire-object.h"
26 #include "psppire-case-file.h"
27
28 #include <gtksheet/gtkextra-marshal.h>
29
30 #include <data/case.h>
31 #include <ui/flexifile.h>
32 #include <data/casefile.h>
33 #include <data/data-in.h>
34 #include <math/sort.h>
35 #include <libpspp/misc.h>
36
37 /* --- prototypes --- */
38 static void psppire_case_file_class_init        (PsppireCaseFileClass   *class);
39 static void psppire_case_file_init      (PsppireCaseFile        *case_file);
40 static void psppire_case_file_finalize  (GObject                *object);
41
42
43 /* --- variables --- */
44 static GObjectClass     *parent_class = NULL;
45
46 enum  {CASE_CHANGED, 
47        CASE_INSERTED,
48        CASES_DELETED,
49        n_SIGNALS};
50
51 static guint signal[n_SIGNALS];
52
53
54 /* --- functions --- */
55 /**
56  * psppire_case_file_get_type:
57  * @returns: the type ID for accelerator groups.
58  */
59 GType
60 psppire_case_file_get_type (void)
61 {
62   static GType object_type = 0;
63
64   if (!object_type)
65     {
66       static const GTypeInfo object_info = {
67         sizeof (PsppireCaseFileClass),
68         (GBaseInitFunc) NULL,
69         (GBaseFinalizeFunc) NULL,
70         (GClassInitFunc) psppire_case_file_class_init,
71         NULL,   /* class_finalize */
72         NULL,   /* class_data */
73         sizeof (PsppireCaseFile),
74         0,      /* n_preallocs */
75         (GInstanceInitFunc) psppire_case_file_init,
76       };
77
78       object_type = g_type_register_static (G_TYPE_PSPPIRE_OBJECT, "PsppireCaseFile",
79                                             &object_info, 0);
80     }
81
82   return object_type;
83 }
84
85
86 static void
87 psppire_case_file_class_init (PsppireCaseFileClass *class)
88 {
89   GObjectClass *object_class = G_OBJECT_CLASS (class);
90
91   parent_class = g_type_class_peek_parent (class);
92
93   object_class->finalize = psppire_case_file_finalize;
94
95   signal[CASE_CHANGED] =
96     g_signal_new ("case_changed",
97                   G_TYPE_FROM_CLASS(class),
98                   G_SIGNAL_RUN_FIRST,
99                   0,
100                   NULL, NULL,
101                   g_cclosure_marshal_VOID__INT,
102                   G_TYPE_NONE, 
103                   1,
104                   G_TYPE_INT);
105
106
107   signal[CASE_INSERTED] =
108     g_signal_new ("case_inserted",
109                   G_TYPE_FROM_CLASS(class),
110                   G_SIGNAL_RUN_FIRST,
111                   0,
112                   NULL, NULL,
113                   g_cclosure_marshal_VOID__INT,
114                   G_TYPE_NONE, 
115                   1,
116                   G_TYPE_INT);
117
118
119   signal[CASES_DELETED] =
120     g_signal_new ("cases_deleted",
121                   G_TYPE_FROM_CLASS(class),
122                   G_SIGNAL_RUN_FIRST,
123                   0,
124                   NULL, NULL,
125                   gtkextra_VOID__INT_INT,
126                   G_TYPE_NONE, 
127                   2,
128                   G_TYPE_INT, G_TYPE_INT);
129 }
130
131 static void
132 psppire_case_file_finalize (GObject *object)
133 {
134   PsppireCaseFile *cf = PSPPIRE_CASE_FILE (object);
135   
136   if ( cf->flexifile) 
137     casefile_destroy(cf->flexifile);
138
139   G_OBJECT_CLASS (parent_class)->finalize (object);
140 }
141
142 static void
143 psppire_case_file_init (PsppireCaseFile *cf)
144 {
145   cf->flexifile = 0;
146 }
147
148 /**
149  * psppire_case_file_new:
150  * @returns: a new #PsppireCaseFile object
151  * 
152  * Creates a new #PsppireCaseFile. 
153  */
154 PsppireCaseFile*
155 psppire_case_file_new (gint val_cnt)
156 {
157   PsppireCaseFile *cf = g_object_new (G_TYPE_PSPPIRE_CASE_FILE, NULL);
158
159   cf->flexifile = flexifile_create (val_cnt);
160
161   return cf;
162 }
163
164
165 gboolean
166 psppire_case_file_delete_cases(PsppireCaseFile *cf, gint n_cases, gint first)
167 {
168   int result;
169
170   g_return_val_if_fail(cf, FALSE);
171   g_return_val_if_fail(cf->flexifile, FALSE);
172
173   result =  flexifile_delete_cases(FLEXIFILE(cf->flexifile), n_cases,  first);
174
175   g_signal_emit(cf, signal[CASES_DELETED], 0, n_cases, first);
176
177   return result;
178 }
179
180 /* Insert case CC into the case file before POSN */
181 gboolean
182 psppire_case_file_insert_case(PsppireCaseFile *cf, 
183                               struct ccase *cc,
184                               gint posn)
185 {
186   bool result ;
187
188   g_return_val_if_fail(cf, FALSE);
189   g_return_val_if_fail(cf->flexifile, FALSE);
190
191   result = flexifile_insert_case(FLEXIFILE(cf->flexifile), cc, posn);
192   
193   if ( result ) 
194     g_signal_emit(cf, signal[CASE_INSERTED], 0, posn);
195   else
196     g_warning("Cannot insert case at position %d\n", posn);
197                 
198   return result;
199 }
200
201
202 /* Append a case to the case file */
203 gboolean
204 psppire_case_file_append_case(PsppireCaseFile *cf, 
205                               struct ccase *c)
206 {
207   bool result ;
208   gint posn ;
209
210   g_return_val_if_fail(cf, FALSE);
211   g_return_val_if_fail(cf->flexifile, FALSE);
212
213   posn = casefile_get_case_cnt(cf->flexifile);
214
215   result = casefile_append(cf->flexifile, c);
216   
217   g_signal_emit(cf, signal[CASE_INSERTED], 0, posn);
218                 
219   return result;
220 }
221
222
223 inline gint
224 psppire_case_file_get_case_count(const PsppireCaseFile *cf)
225 {
226   g_return_val_if_fail(cf, FALSE);
227   
228   if ( ! cf->flexifile) 
229     return 0;
230
231   return casefile_get_case_cnt(cf->flexifile);
232 }
233
234 /* Return the IDXth value from case CASENUM.
235    The return value must not be freed or written to
236  */
237 const union value *
238 psppire_case_file_get_value(const PsppireCaseFile *cf, gint casenum, gint idx)
239 {
240   const union value *v; 
241   struct ccase c;
242
243   g_return_val_if_fail(cf, NULL);
244   g_return_val_if_fail(cf->flexifile, NULL);
245
246   g_return_val_if_fail(idx < casefile_get_value_cnt(cf->flexifile), NULL);
247
248   flexifile_get_case(FLEXIFILE(cf->flexifile), casenum, &c);
249
250   v = case_data(&c, idx);
251
252   case_destroy(&c);
253
254   return v;
255 }
256
257 void
258 psppire_case_file_clear(PsppireCaseFile *cf)
259 {
260   casefile_destroy(cf->flexifile);
261   cf->flexifile = 0;
262   g_signal_emit(cf, signal[CASES_DELETED], 0, 0, -1);
263 }
264
265 /* Set the IDXth value of case C to SYSMIS/EMPTY */
266 gboolean
267 psppire_case_file_set_value(PsppireCaseFile *cf, gint casenum, gint idx,
268                             union value *v, gint width)
269 {
270   struct ccase cc ;
271   int bytes;
272
273   g_return_val_if_fail(cf, FALSE);
274   g_return_val_if_fail(cf->flexifile, FALSE);
275
276   g_return_val_if_fail(idx < casefile_get_value_cnt(cf->flexifile), FALSE);
277
278   if ( ! flexifile_get_case(FLEXIFILE(cf->flexifile), casenum, &cc) )
279     return FALSE;
280
281   if ( width == 0 ) 
282     bytes = MAX_SHORT_STRING;
283   else
284     bytes = DIV_RND_UP(width, MAX_SHORT_STRING) * MAX_SHORT_STRING ;
285
286   /* Cast away const in flagrant abuse of the casefile */
287   memcpy((union value *)case_data(&cc, idx), v, bytes);
288
289   g_signal_emit(cf, signal[CASE_CHANGED], 0, casenum);
290
291   return TRUE;
292 }
293
294
295
296 /* Set the IDXth value of case C using D_IN */
297 gboolean
298 psppire_case_file_data_in(PsppireCaseFile *cf, gint casenum, gint idx,
299                           struct substring input, const struct fmt_spec *fmt)
300 {
301   struct ccase cc ;
302
303   g_return_val_if_fail(cf, FALSE);
304   g_return_val_if_fail(cf->flexifile, FALSE);
305
306   g_return_val_if_fail(idx < casefile_get_value_cnt(cf->flexifile), FALSE);
307
308   if ( ! flexifile_get_case(FLEXIFILE(cf->flexifile), casenum, &cc) )
309     return FALSE;
310
311   /* Cast away const in flagrant abuse of the casefile */
312   if (!data_in (input, fmt->type, 0, 0,
313                 (union value *) case_data(&cc, idx), fmt_var_width (fmt)))
314     g_warning("Cant set value\n");
315
316   g_signal_emit(cf, signal[CASE_CHANGED], 0, casenum);
317
318   return TRUE;
319 }
320
321
322 void
323 psppire_case_file_sort(PsppireCaseFile *cf, const struct sort_criteria *sc)
324 {
325   struct ccase cc;
326   gint c;
327   struct casefile *cfile;
328   struct casereader *reader = casefile_get_reader (cf->flexifile, NULL);
329   const int value_cnt = casefile_get_value_cnt(cf->flexifile);
330
331   cfile = sort_execute(reader, sc);
332
333   casefile_destroy(cf->flexifile);
334
335   /* Copy casefile into flexifile */
336
337   reader = casefile_get_destructive_reader(cfile);
338   cf->flexifile = flexifile_create(value_cnt);
339   while(casereader_read(reader, &cc))
340       casefile_append(cf->flexifile, &cc);
341   
342
343   /* FIXME: Need to have a signal to change a range of cases, instead of
344      calling a signal many times */
345   for ( c = 0 ; c < casefile_get_case_cnt(cf->flexifile) ; ++c ) 
346     g_signal_emit(cf, signal[CASE_CHANGED], 0, c);
347 }
348
349
350 /* Resize the cases in the casefile, by inserting N_VALUES into every 
351    one of them. */
352 gboolean 
353 psppire_case_file_insert_values (PsppireCaseFile *cf, 
354                                  gint n_values, gint before)
355 {
356   g_return_val_if_fail(cf, FALSE);
357
358   if ( ! cf->flexifile ) 
359     {
360       cf->flexifile = flexifile_create(n_values);
361       return TRUE;
362     }
363
364   return flexifile_resize (FLEXIFILE(cf->flexifile), n_values, before);
365 }
366
367 /* Fills C with the CASENUMth case.
368    Returns true on success, false otherwise.
369  */
370 gboolean
371 psppire_case_file_get_case (const PsppireCaseFile *cf, gint casenum, 
372                            struct ccase *c)
373 {
374   g_return_val_if_fail (cf, FALSE);
375   g_return_val_if_fail (cf->flexifile, FALSE);
376
377   return flexifile_get_case (FLEXIFILE(cf->flexifile), casenum, c);
378 }