/[pspp]/psppire/src/callbacks.c
ViewVC logotype

Diff of /psppire/src/callbacks.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.10 by jmd, Thu Nov 3 05:42:48 2005 UTC revision 1.11 by jmd, Sat Nov 12 07:52:06 2005 UTC
# Line 1  Line 1 
1  /*  /*
2      PSPPIRE --- A Graphical User Interface for PSPP      PSPPIRE --- A Graphical User Interface for PSPP
3      Copyright (C) 2004  Free Software Foundation      Copyright (C) 2004, 2005  Free Software Foundation
4      Written by John Darrington      Written by John Darrington
5    
6      This program is free software; you can redistribute it and/or modify      This program is free software; you can redistribute it and/or modify
# Line 18  Line 18 
18      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19      02110-1301, USA. */      02110-1301, USA. */
20    
21    #include <hacks.h>
22    #include <config.h>
23    #include <stdlib.h>
24    #include <file-handle-def.h>
25    #include <sfm-read.h>
26    #include <case.h>
27    
28    #include <hacks.h>
29  #include <psppire-conf.h>  #include <psppire-conf.h>
30    
31  #include <glade/glade.h>  #include <glade/glade.h>
32  #include <gtk/gtk.h>  #include <gtk/gtk.h>
33    
34    #include <gtksheet.h>
35  #include "callbacks.h"  #include "callbacks.h"
36  #include "pspp-dict.h"  #include "pspp-dict.h"
37  #include <gtksheet.h>  
38  #include <file-handle-def.h>  #include "var_sheet.h"
39    
40    
41  #define _(A) A  #define _(A) A
42  #define N_(A) A  #define N_(A) A
# Line 34  Line 44 
44    
45  extern GladeXML *xml;  extern GladeXML *xml;
46    
47  static struct file_handle *psppire_handle = 0;  static struct file_handle *save_handle = 0;
 static PSPP_Dict *pspp_dictionary = 0;  
48    
49    
50  void  void
51  psppire_reinitialise()  on_new1_activate                       (GtkMenuItem     *menuitem,
52                                            gpointer         user_data)
53  {  {
54    GtkWidget *var_sheet;    GtkWidget *var_sheet  = glade_xml_get_widget(xml, "variable_sheet");
55    GtkWidget *data_sheet;    GtkWidget *data_sheet  = glade_xml_get_widget(xml, "data_sheet");
   GtkWidget *window1 ;  
   GtkWidget *var_type_dialog ;  
56    
57      PSPP_Dict *dict = psppire_var_sheet_get_dictionary(var_sheet);
58    
59    if ( pspp_dictionary )    pspp_dict_clear(dict);
     g_object_unref(pspp_dictionary);  
60    
61    pspp_dictionary = pspp_dict_new();    psppire_var_sheet_clear(GTK_SHEET(var_sheet));
62      psppire_data_sheet_clear(GTK_SHEET(data_sheet));
63    
64    if ( psppire_handle)    if (save_handle)
65      destroy_file_handle(psppire_handle, 0);      destroy_file_handle(save_handle, 0);
66    psppire_handle = 0;    save_handle = 0 ;
67    }
68    
   var_sheet = glade_xml_get_widget(xml, "variable_sheet");  
69    
70    psppire_var_sheet_set_dictionary(var_sheet, pspp_dictionary);  void
71    psppire_var_sheet_clear(var_sheet);  on_open1_activate                      (GtkMenuItem     *menuitem,
72                                            gpointer         user_data)
73    {
74      GtkWidget *dialog;
75      GtkWidget *window1  = glade_xml_get_widget(xml, "window1");
76    
77      dialog = gtk_file_chooser_dialog_new (_("Open"),
78                                            GTK_WINDOW(window1),
79                                            GTK_FILE_CHOOSER_ACTION_OPEN,
80                                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
81                                            GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
82                                            NULL);
83    
84    
85    data_sheet = glade_xml_get_widget(xml, "data_sheet");    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
86    psppire_data_sheet_set_dictionary(data_sheet, pspp_dictionary);      {
87    psppire_data_sheet_clear(data_sheet);        struct file_handle *read_handle = 0;
88    
89    window1 = glade_xml_get_widget(xml, "window1");        GtkWidget *data_sheet = glade_xml_get_widget(xml, "data_sheet");
90    var_type_dialog = glade_xml_get_widget(xml, "var_type_dialog");        g_assert(data_sheet);
91    
92    gtk_window_set_transient_for    (var_type_dialog, window1);        GtkWidget *var_sheet = glade_xml_get_widget(xml, "variable_sheet");
93  }        g_assert(var_sheet);
94    
95  void        char *filename = gtk_file_chooser_get_filename
96  on_new1_activate                       (GtkMenuItem     *menuitem,          (GTK_FILE_CHOOSER (dialog));
                                         gpointer         user_data)  
 {  
   psppire_reinitialise();  
 }  
97    
98          read_handle =
99            create_file_handle_with_defaults ("__read_handle", filename);
100          g_free (filename);
101    
102  void        if ( !read_handle )
103  on_open1_activate                      (GtkMenuItem     *menuitem,          {
104                                          gpointer         user_data)            g_warning("Cannot read handle for reading system file \"%s\"\n",
105  {                      filename);
106              return;
107            }
108    
109          /* Clear everything */
110          PSPP_Dict *dict = psppire_var_sheet_get_dictionary(var_sheet);
111          pspp_dict_clear(dict);
112    
113          psppire_var_sheet_clear(GTK_SHEET(var_sheet));
114          psppire_data_sheet_clear(GTK_SHEET(data_sheet));
115    
116          struct dictionary *new_dict;
117          struct sfm_read_info ri;
118          struct sfm_reader *reader ;
119    
120          reader = sfm_open_reader (read_handle, &new_dict, &ri);
121          g_assert(reader);
122    
123          dict = pspp_dict_new_from_dict(new_dict);
124    
125          psppire_var_sheet_set_dictionary(GTK_SHEET(var_sheet), dict);
126          psppire_data_sheet_set_dictionary(GTK_SHEET(data_sheet), dict);
127    
128          const int ni = dict_get_next_value_idx(dict->dict);
129          if ( ni == 0 )
130            return;
131    
132          gint var_idx;      
133    
134          for ( var_idx = 0 ;
135                var_idx < pspp_dict_get_var_cnt(dict);
136                ++var_idx)
137            pspp_dict_var_changed(dict, var_idx);
138          
139          gint case_num;
140          for(case_num=0;;case_num++)
141          {
142            struct ccase mycase;
143    
144            case_create(&mycase, ni);
145    
146            if ( ! sfm_read_case (reader, &mycase) )
147              {
148                case_destroy(&mycase);
149                break;
150              }
151    
152            for ( var_idx = 0 ;
153                  var_idx < pspp_dict_get_var_cnt(dict);
154                  ++var_idx)
155              {
156                GValue val = {0};
157                const struct variable *v = pspp_dict_get_var(dict, var_idx);
158                union value *value = case_data(&mycase, v->fv);
159    
160                if ( v->type == ALPHA)
161                  {
162                    gchar *text = g_malloc(sizeof (gchar) * (v->width + 1));
163                    g_value_init(&val, G_TYPE_STRING);
164                    
165                    memcpy(text, value->s, v->width);
166                    value->s[v->width] = '\0';
167                
168                    g_value_set_string(&val, text);
169                    g_free(text);
170                  }
171                else
172                  {
173                    g_value_init(&val, G_TYPE_DOUBLE);
174                    g_value_set_double(&val, value->f);
175                  }
176    
177                data_sheet_set_cell_value(GTK_SHEET(data_sheet),
178                                          case_num, var_idx, &val);
179    
180                g_value_unset(&val);
181              }
182    
183            case_destroy(&mycase);
184          }
185    
186          sfm_close_reader(reader);
187    
188          destroy_file_handle(read_handle, 0);
189    
190          if (save_handle)
191            destroy_file_handle(save_handle, 0);
192          save_handle = 0;
193        }
194    
195      gtk_widget_destroy (dialog);
196  }  }
197    
198    
199  void  /* Re initialise HANDLE, by interrogating the user for a new file name */
200  recreate_file_handle(struct file_handle **handle)  static void
201    recreate_save_handle(struct file_handle **handle)
202  {  {
203    GtkWidget *dialog;    GtkWidget *dialog;
204    
# Line 109  recreate_file_handle(struct file_handle Line 218  recreate_file_handle(struct file_handle
218    
219        if ( *handle )        if ( *handle )
220          destroy_file_handle(*handle, 0);          destroy_file_handle(*handle, 0);
221        *handle = create_file_handle_with_defaults ("__psppire_handle",        *handle = create_file_handle_with_defaults ("__psppire_save_handle",
222                                                    filename);                                                    filename);
   
223        g_free (filename);        g_free (filename);
   
224      }      }
     
225    
226    gtk_widget_destroy (dialog);    gtk_widget_destroy (dialog);
   
227  }  }
228    
229  void  void
230  on_save1_activate                      (GtkMenuItem     *menuitem,  on_save1_activate                      (GtkMenuItem     *menuitem,
231                                          gpointer         user_data)                                          gpointer         user_data)
232  {  {
233    if ( ! psppire_handle )    if ( ! save_handle )
234      recreate_file_handle(&psppire_handle);      recreate_save_handle(&save_handle);
235        
236        
237    GtkWidget *data_sheet = glade_xml_get_widget(xml, "data_sheet");    GtkWidget *data_sheet = glade_xml_get_widget(xml, "data_sheet");
238      GtkWidget *var_sheet = glade_xml_get_widget(xml, "variable_sheet");
239    
240    if ( psppire_handle )    PSPP_Dict *dict = psppire_var_sheet_get_dictionary(var_sheet);
241      psppire_create_system_file(data_sheet, pspp_dictionary, psppire_handle);    
242      if ( save_handle )
243        psppire_create_system_file(data_sheet, dict, save_handle);
244  }  }
245    
246    
# Line 141  void Line 248  void
248  on_save_as1_activate                   (GtkMenuItem     *menuitem,  on_save_as1_activate                   (GtkMenuItem     *menuitem,
249                                          gpointer         user_data)                                          gpointer         user_data)
250  {  {
251    recreate_file_handle(&psppire_handle);    recreate_save_handle(&save_handle);
252    if ( ! psppire_handle )    if ( ! save_handle )
253      return ;      return ;
254    
255    GtkWidget *data_sheet = glade_xml_get_widget(xml, "data_sheet");    GtkWidget *data_sheet = glade_xml_get_widget(xml, "data_sheet");
256      GtkWidget *var_sheet = glade_xml_get_widget(xml, "variable_sheet");
257    
258      PSPP_Dict *dict = psppire_var_sheet_get_dictionary(var_sheet);
259    
260    if ( psppire_handle )    if ( save_handle )
261      psppire_create_system_file(data_sheet, pspp_dictionary, psppire_handle);      psppire_create_system_file(data_sheet, dict, save_handle);
262  }  }
263    
264    
# Line 206  on_delete1_activate                    ( Line 316  on_delete1_activate                    (
316          gint row;          gint row;
317          gint col;          gint col;
318          GtkWidget *var_sheet;          GtkWidget *var_sheet;
   
319          var_sheet = glade_xml_get_widget(xml, "variable_sheet");          var_sheet = glade_xml_get_widget(xml, "variable_sheet");
320    
321            PSPP_Dict *dict = psppire_var_sheet_get_dictionary(var_sheet);
322    
323    
324          gtk_sheet_get_active_cell(GTK_SHEET(var_sheet), &row, &col);          gtk_sheet_get_active_cell(GTK_SHEET(var_sheet), &row, &col);
325    
326          pspp_dict_delete_var(pspp_dictionary, row);          pspp_dict_delete_var(dict, row);
327                    
328        }        }
329        break;        break;

Legend:
Removed from v.1.10  
changed lines
  Added in v.1.11

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26