Whitespace changes only.
authorJohn Darrington <john@darrington.wattle.id.au>
Sun, 24 Dec 2006 22:49:18 +0000 (22:49 +0000)
committerJohn Darrington <john@darrington.wattle.id.au>
Sun, 24 Dec 2006 22:49:18 +0000 (22:49 +0000)
28 files changed:
src/ui/gui/customentry.c
src/ui/gui/data-editor.h
src/ui/gui/data-sheet.c
src/ui/gui/data-sheet.h
src/ui/gui/flexifile-factory.c
src/ui/gui/helper.c
src/ui/gui/helper.h
src/ui/gui/message-dialog.c
src/ui/gui/message-dialog.h
src/ui/gui/missing-val-dialog.c
src/ui/gui/missing-val-dialog.h
src/ui/gui/psppire-case-file.c
src/ui/gui/psppire-case-file.h
src/ui/gui/psppire-data-store.c
src/ui/gui/psppire-data-store.h
src/ui/gui/psppire-dict.c
src/ui/gui/psppire-dict.h
src/ui/gui/psppire-object.h
src/ui/gui/psppire-var-store.c
src/ui/gui/psppire-var-store.h
src/ui/gui/psppire.c
src/ui/gui/sort-cases-dialog.c
src/ui/gui/sort-cases-dialog.h
src/ui/gui/val-labs-dialog.h
src/ui/gui/var-sheet.c
src/ui/gui/var-sheet.h
src/ui/gui/var-type-dialog.c
src/ui/gui/var-type-dialog.h

index 961a4e47227436d2f20b5b6b9ae987b5b79c4751..b2c25aa395c240ed1b276e518de5092a1a05a489 100644 (file)
@@ -403,7 +403,7 @@ psppire_custom_entry_size_allocate (GtkWidget     *widget,
   g_return_if_fail (allocation != NULL);
 
   ce = PSPPIRE_CUSTOM_ENTRY (widget);
-  button_width = psppire_custom_entry_get_button_width(ce);
+  button_width = psppire_custom_entry_get_button_width (ce);
   panel_width = button_width + 2 * widget->style->xthickness;
 
   widget->allocation = *allocation;
index d0c6d0905c39864387b82ec34c25f5a0c6c9b4ac..63b82a4a67e14c0f9243c0ab809b39fe3b75c2dd 100644 (file)
@@ -38,7 +38,7 @@ void new_data_window (GtkMenuItem *, gpointer);
 
 void open_data_window (GtkMenuItem *, gpointer);
 
-void data_editor_select_sheet(struct data_editor *de, gint page);
+void data_editor_select_sheet (struct data_editor *de, gint page);
 
 
 #endif
index bdb18b1e7a506c28d75a5b364fc141340b0e9483..577b9551b9daf082b98aeb287acb6aeee5b52199 100644 (file)
@@ -49,17 +49,17 @@ traverse_callback (GtkSheet * sheet,
   gint n_vars;
 
   PsppireDataStore *data_store =
-    PSPPIRE_DATA_STORE(gtk_sheet_get_model(sheet));
+    PSPPIRE_DATA_STORE(gtk_sheet_get_model (sheet));
 
 
   g_assert (data_store);
 
-  n_vars = psppire_dict_get_var_cnt(data_store->dict);
+  n_vars = psppire_dict_get_var_cnt (data_store->dict);
 
   if ( *new_column >= n_vars )
     return FALSE;
 
-  case_count = psppire_case_file_get_case_count(data_store->case_file);
+  case_count = psppire_case_file_get_case_count (data_store->case_file);
 
   if ( *new_row >= case_count )
     {
@@ -78,7 +78,7 @@ traverse_callback (GtkSheet * sheet,
 
 /* Update the data_ref_entry with the reference of the active cell */
 gint
-update_data_ref_entry(const GtkSheet *sheet, gint row, gint col)
+update_data_ref_entry (const GtkSheet *sheet, gint row, gint col)
 {
 
   GladeXML *data_editor_xml = NULL; /* FIXME !!!! */
@@ -87,11 +87,11 @@ update_data_ref_entry(const GtkSheet *sheet, gint row, gint col)
   /* The entry where the reference to the current cell is displayed */
   GtkEntry *cell_ref_entry;
 
-  PsppireDataStore *data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model(sheet));
+  PsppireDataStore *data_store = PSPPIRE_DATA_STORE(gtk_sheet_get_model (sheet));
   if (data_store)
     {
       const struct variable *pv =
-       psppire_dict_get_variable(data_store->dict, col);
+       psppire_dict_get_variable (data_store->dict, col);
 
       gchar *text ;
       gchar *s ;
@@ -99,19 +99,19 @@ update_data_ref_entry(const GtkSheet *sheet, gint row, gint col)
       if ( !data_editor_xml)
        return FALSE;
 
-      text = g_strdup_printf("%d: %s", row,
+      text = g_strdup_printf ("%d: %s", row,
                             pv ? var_get_name (pv) : "");
 
       cell_ref_entry = GTK_ENTRY(get_widget_assert (data_editor_xml,
                                                   "cell_ref_entry"));
 
-      s = pspp_locale_to_utf8(text, -1, 0);
+      s = pspp_locale_to_utf8 (text, -1, 0);
 
-      g_free(text);
+      g_free (text);
 
-      gtk_entry_set_text(cell_ref_entry, s);
+      gtk_entry_set_text (cell_ref_entry, s);
 
-      g_free(s);
+      g_free (s);
     }
 
   return FALSE;
@@ -122,7 +122,7 @@ extern PsppireDataStore *the_data_store ;
 
 /* Return the width that an  'M' character would occupy when typeset in WIDGET */
 static guint
-calc_m_width(GtkWidget *widget, const PangoFontDescription *font_desc)
+calc_m_width (GtkWidget *widget, const PangoFontDescription *font_desc)
 {
   PangoRectangle rect;
   PangoLayout *layout ;
@@ -139,8 +139,8 @@ calc_m_width(GtkWidget *widget, const PangoFontDescription *font_desc)
 
   pango_layout_get_extents (layout, NULL, &rect);
 
-  g_object_unref(G_OBJECT(layout));
-  g_object_unref(G_OBJECT(context));
+  g_object_unref (G_OBJECT(layout));
+  g_object_unref (G_OBJECT(context));
 
   return PANGO_PIXELS(rect.width);
 }
@@ -148,12 +148,12 @@ calc_m_width(GtkWidget *widget, const PangoFontDescription *font_desc)
 
 
 void
-font_change_callback(GObject *obj, gpointer data)
+font_change_callback (GObject *obj, gpointer data)
 {
   GtkWidget *sheet  = data;
   PsppireDataStore *ds = PSPPIRE_DATA_STORE(obj);
 
-  ds->width_of_m = calc_m_width(sheet, ds->font_desc);
+  ds->width_of_m = calc_m_width (sheet, ds->font_desc);
 }
 
 GtkWidget*
@@ -162,10 +162,10 @@ psppire_data_sheet_create (gchar *widget_name, gchar *string1, gchar *string2,
 {
   GtkWidget *sheet;
 
-  sheet = gtk_sheet_new(G_SHEET_ROW(the_data_store),
+  sheet = gtk_sheet_new (G_SHEET_ROW(the_data_store),
                        G_SHEET_COLUMN(the_data_store), "data sheet", 0);
 
-  the_data_store->width_of_m = calc_m_width(sheet, the_data_store->font_desc);
+  the_data_store->width_of_m = calc_m_width (sheet, the_data_store->font_desc);
 
   g_signal_connect (G_OBJECT (sheet), "activate",
                    G_CALLBACK (update_data_ref_entry),
@@ -178,12 +178,12 @@ psppire_data_sheet_create (gchar *widget_name, gchar *string1, gchar *string2,
   g_signal_connect (G_OBJECT (the_data_store), "font-changed",
                    G_CALLBACK (font_change_callback), sheet);
 
-  gtk_sheet_set_active_cell(GTK_SHEET(sheet), -1, -1);
+  gtk_sheet_set_active_cell (GTK_SHEET(sheet), -1, -1);
 
 
-  gtk_sheet_set_model(sheet, G_SHEET_MODEL(the_data_store));
+  gtk_sheet_set_model (sheet, G_SHEET_MODEL(the_data_store));
 
-  gtk_widget_show(sheet);
+  gtk_widget_show (sheet);
 
   return sheet;
 }
index f4dfb39249165269f17d51d96af31108eb3f58c2..4e8b8c450d9dbbbd955b2315f3e49cb9a39a4351 100644 (file)
 #include <gtksheet/gtksheet.h>
 #include "psppire-dict.h"
 
-void psppire_data_sheet_clear(GtkSheet *sheet);
+void psppire_data_sheet_clear (GtkSheet *sheet);
 
 #if 0
-void psppire_data_sheet_set_dictionary(GtkSheet *sheet, PsppireDict *d);
+void psppire_data_sheet_set_dictionary (GtkSheet *sheet, PsppireDict *d);
 #endif
 
 GtkWidget* psppire_data_sheet_create (gchar *widget_name,
@@ -36,16 +36,16 @@ GtkWidget* psppire_data_sheet_create (gchar *widget_name,
                                      gint int1, gint int2);
 
 
-void data_sheet_set_cell_value(GtkSheet *sheet, gint row, gint col,
+void data_sheet_set_cell_value (GtkSheet *sheet, gint row, gint col,
                               const GValue *value);
 
 
-void psppire_data_sheet_set_show_labels(GtkSheet *sheet, gboolean show_labels);
+void psppire_data_sheet_set_show_labels (GtkSheet *sheet, gboolean show_labels);
 
 /* Repair any damage that may have been done to the data sheet */
-void psppire_data_sheet_redisplay(GtkSheet *sheet);
+void psppire_data_sheet_redisplay (GtkSheet *sheet);
 
-guint columnWidthToPixels(GtkSheet *sheet, gint column, guint width);
+guint columnWidthToPixels (GtkSheet *sheet, gint column, guint width);
 
 
 #endif
index 453253c9d672f93761c0554682f259c1f4b7847a..bbfb340cc4a956a4104e81f11de8bb1bde3376e6 100644 (file)
@@ -31,7 +31,7 @@ struct flexifile_factory
 
 
 static struct casefile *
-produce_flexifile(struct casefile_factory *this UNUSED, size_t value_cnt)
+produce_flexifile (struct casefile_factory *this UNUSED, size_t value_cnt)
 {
   struct casefile *ff =  flexifile_create (value_cnt);
 
index d73217b3a1c788ed41d46590a39aed452af93dc8..ae645a61477bb867a3c70f557cf92ff759ab62d3 100644 (file)
 /* Formats a value according to FORMAT
    The returned string must be freed when no longer required */
 gchar *
-value_to_text(union value v, struct fmt_spec format)
+value_to_text (union value v, struct fmt_spec format)
 {
   gchar *s = 0;
 
-  s = g_new(gchar, format.w + 1);
-  data_out(&v, &format, s);
+  s = g_new (gchar, format.w + 1);
+  data_out (&v, &format, s);
   s[format.w]='\0';
-  g_strchug(s);
+  g_strchug (s);
 
   return s;
 }
@@ -29,7 +29,7 @@ value_to_text(union value v, struct fmt_spec format)
 
 
 gboolean
-text_to_value(const gchar *text, union value *v,
+text_to_value (const gchar *text, union value *v,
              struct fmt_spec format)
 {
   bool ok;
@@ -40,9 +40,9 @@ text_to_value(const gchar *text, union value *v,
 
       {
        const gchar *s = text;
-       while(*s)
+       while (*s)
          {
-           if ( !isspace(*s))
+           if ( !isspace (*s))
              break;
            s++;
          }
@@ -61,24 +61,24 @@ text_to_value(const gchar *text, union value *v,
 
 
 GtkWidget *
-get_widget_assert(GladeXML *xml, const gchar *name)
+get_widget_assert (GladeXML *xml, const gchar *name)
 {
   GtkWidget *w;
-  g_assert(xml);
-  g_assert(name);
+  g_assert (xml);
+  g_assert (name);
 
-  w = glade_xml_get_widget(xml, name);
+  w = glade_xml_get_widget (xml, name);
 
   if ( !w )
-    g_warning("Widget \"%s\" could not be found\n", name);
+    g_warning ("Widget \"%s\" could not be found\n", name);
 
   return w;
 }
 
 /* Converts a string in the pspp locale to utf-8 */
 char *
-pspp_locale_to_utf8(const gchar *text, gssize len, GError **err)
+pspp_locale_to_utf8 (const gchar *text, gssize len, GError **err)
 {
-  return recode_string(CONV_PSPP_TO_UTF8, text, len);
+  return recode_string (CONV_PSPP_TO_UTF8, text, len);
 }
 
index 407773b1c28bfd1141ed079c59bfc386096343f8..3d8d6420b1b8ec307bea4b3e8a6b0bdc81e6def2 100644 (file)
 
 /* Formats a value according to FORMAT
    The returned string must be freed when no longer required */
-gchar * value_to_text(union value v, struct fmt_spec format);
+gchar * value_to_text (union value v, struct fmt_spec format);
 
 
-gboolean text_to_value(const gchar *text, union value *v,
+gboolean text_to_value (const gchar *text, union value *v,
                       struct fmt_spec format);
 
-GtkWidget * get_widget_assert(GladeXML *xml, const gchar *name);
+GtkWidget * get_widget_assert (GladeXML *xml, const gchar *name);
 
 /* Converts a string in the pspp locale to utf-8 */
-char * pspp_locale_to_utf8(const gchar *text, gssize len, GError **err);
+char * pspp_locale_to_utf8 (const gchar *text, gssize len, GError **err);
 
 
 #endif
index 61847de789ced8c9434d5620e37c2e22ac743ab0..9d3dc9bb7a86e9076364440464bc608250731027 100644 (file)
@@ -48,19 +48,19 @@ static GQueue *message_queue;
 void
 message_dialog_init (struct source_stream *ss)
 {
-  message_queue = g_queue_new();
+  message_queue = g_queue_new ();
   msg_init (ss, enqueue_msg);
 }
 
 void
 message_dialog_done (void)
 {
-  msg_done();
-  g_queue_free(message_queue);
+  msg_done ();
+  g_queue_free (message_queue);
 }
 
 static gboolean
-dequeue_message(gpointer data)
+dequeue_message (gpointer data)
 {
   struct msg * m ;
 
@@ -68,15 +68,15 @@ dequeue_message(gpointer data)
      a modal dialog box, will cause an impossible situation.
      So don't pop it up just yet.
   */
-  if ( gdk_pointer_is_grabbed())
+  if ( gdk_pointer_is_grabbed ())
     return TRUE;
 
-  m = g_queue_pop_tail(message_queue);
+  m = g_queue_pop_tail (message_queue);
 
   if ( m )
     {
-      popup_message(m);
-      msg_destroy(m);
+      popup_message (m);
+      msg_destroy (m);
       return TRUE;
     }
 
@@ -84,18 +84,18 @@ dequeue_message(gpointer data)
 }
 
 static void
-enqueue_msg(const struct msg *msg)
+enqueue_msg (const struct msg *msg)
 {
-  struct msg *m = msg_dup(msg);
+  struct msg *m = msg_dup (msg);
 
-  g_queue_push_head(message_queue, m);
+  g_queue_push_head (message_queue, m);
 
-  g_idle_add(dequeue_message, 0);
+  g_idle_add (dequeue_message, 0);
 }
 
 
 void
-popup_message(const struct msg *m)
+popup_message (const struct msg *m)
 {
   GtkWindow *parent;
   GtkWidget *dialog;
@@ -139,7 +139,7 @@ popup_message(const struct msg *m)
                                  GTK_BUTTONS_CLOSE,
                                  msg);
 
-  gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
+  gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG(dialog),
                                            _("%s (line %d) %s"),
                                           m->where.file_name,
                                           m->where.line_number,
@@ -147,7 +147,7 @@ popup_message(const struct msg *m)
 
   gtk_window_set_keep_above (GTK_WINDOW(dialog), TRUE);
 
-  gtk_dialog_run(GTK_DIALOG(dialog));
+  gtk_dialog_run (GTK_DIALOG(dialog));
 
   gtk_widget_destroy (dialog);
 }
index 63de934e4dcef90a4a6dd7c9138ab48aaa2f9c4f..e5a6e2f62635031f795334b44d5391aed720709d 100644 (file)
@@ -27,6 +27,6 @@ struct source_stream ;
 
 void message_dialog_init (struct source_stream *);
 void message_dialog_done (void);
-void popup_message(const struct msg *m);
+void popup_message (const struct msg *m);
 
 #endif
index 3ffcda07855fe4283a8ce7dc80503c80b9c01139..351279883542e8206be470e549b59ba45a6cee65 100644 (file)
@@ -41,7 +41,7 @@
 
 /* A simple (sub) dialog box for displaying user input errors */
 static void
-err_dialog(const gchar *msg, GtkWindow *window)
+err_dialog (const gchar *msg, GtkWindow *window)
 {
   GtkWidget *hbox ;
   GtkWidget *label = gtk_label_new (msg);
@@ -57,7 +57,7 @@ err_dialog(const gchar *msg, GtkWindow *window)
                                 NULL);
 
 
-  GtkWidget *icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_ERROR,
+  GtkWidget *icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_ERROR,
                                             GTK_ICON_SIZE_DIALOG);
 
   g_signal_connect_swapped (dialog,
@@ -65,13 +65,13 @@ err_dialog(const gchar *msg, GtkWindow *window)
                            G_CALLBACK (gtk_widget_destroy),
                            dialog);
 
-  hbox = gtk_hbox_new(FALSE, 10);
+  hbox = gtk_hbox_new (FALSE, 10);
 
   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
                     hbox);
 
-  gtk_box_pack_start(GTK_BOX(hbox), icon, TRUE, FALSE, 10);
-  gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 10);
+  gtk_box_pack_start (GTK_BOX(hbox), icon, TRUE, FALSE, 10);
+  gtk_box_pack_start (GTK_BOX(hbox), label, TRUE, TRUE, 10);
 
   gtk_widget_show_all (dialog);
 }
@@ -79,99 +79,99 @@ err_dialog(const gchar *msg, GtkWindow *window)
 
 /* Callback which occurs when the OK button is clicked */
 static void
-missing_val_dialog_accept(GtkWidget *w, gpointer data)
+missing_val_dialog_accept (GtkWidget *w, gpointer data)
 {
   struct missing_val_dialog *dialog = data;
 
   const struct fmt_spec *write_spec = var_get_write_format (dialog->pv);
 
-  if ( gtk_toggle_button_get_active(dialog->button_discrete))
+  if ( gtk_toggle_button_get_active (dialog->button_discrete))
     {
       gint nvals = 0;
       gint badvals = 0;
       gint i;
-      mv_clear(&dialog->mvl);
-      for(i = 0 ; i < 3 ; ++i )
+      mv_clear (&dialog->mvl);
+      for (i = 0 ; i < 3 ; ++i )
        {
          gchar *text =
-           g_strdup(gtk_entry_get_text(GTK_ENTRY(dialog->mv[i])));
+           g_strdup (gtk_entry_get_text (GTK_ENTRY(dialog->mv[i])));
 
          union value v;
-         if ( !text || strlen(g_strstrip(text)) == 0 )
+         if ( !text || strlen (g_strstrip (text)) == 0 )
            {
-             g_free(text);
+             g_free (text);
              continue;
            }
 
-         if ( text_to_value(text, &v, *write_spec))
+         if ( text_to_value (text, &v, *write_spec))
            {
              nvals++;
              mv_add_value (&dialog->mvl, &v);
            }
          else
              badvals++;
-         g_free(text);
+         g_free (text);
        }
       if ( nvals == 0 || badvals > 0 )
        {
-         err_dialog(_("Incorrect value for variable type"),
+         err_dialog (_("Incorrect value for variable type"),
                     GTK_WINDOW(dialog->window));
          return ;
        }
     }
 
-  if (gtk_toggle_button_get_active(dialog->button_range))
+  if (gtk_toggle_button_get_active (dialog->button_range))
     {
       gchar *discrete_text ;
 
       union value low_val ;
       union value high_val;
-      const gchar *low_text = gtk_entry_get_text(GTK_ENTRY(dialog->low));
-      const gchar *high_text = gtk_entry_get_text(GTK_ENTRY(dialog->high));
+      const gchar *low_text = gtk_entry_get_text (GTK_ENTRY(dialog->low));
+      const gchar *high_text = gtk_entry_get_text (GTK_ENTRY(dialog->high));
 
-      if ( text_to_value(low_text, &low_val, *write_spec)
+      if ( text_to_value (low_text, &low_val, *write_spec)
           &&
-          text_to_value(high_text, &high_val, *write_spec) )
+          text_to_value (high_text, &high_val, *write_spec) )
        {
          if ( low_val.f > high_val.f )
            {
-             err_dialog(_("Incorrect range specification"),
+             err_dialog (_("Incorrect range specification"),
                          GTK_WINDOW(dialog->window));
              return ;
            }
        }
       else
        {
-         err_dialog(_("Incorrect range specification"),
+         err_dialog (_("Incorrect range specification"),
                      GTK_WINDOW(dialog->window));
          return;
        }
 
       discrete_text =
-       g_strdup(gtk_entry_get_text(GTK_ENTRY(dialog->discrete)));
+       g_strdup (gtk_entry_get_text (GTK_ENTRY(dialog->discrete)));
 
-      mv_clear(&dialog->mvl);
-      mv_add_num_range(&dialog->mvl, low_val.f, high_val.f);
+      mv_clear (&dialog->mvl);
+      mv_add_num_range (&dialog->mvl, low_val.f, high_val.f);
 
-      if ( discrete_text && strlen(g_strstrip(discrete_text)) > 0 )
+      if ( discrete_text && strlen (g_strstrip (discrete_text)) > 0 )
        {
          union value discrete_val;
-         if ( !text_to_value(discrete_text, &discrete_val,
+         if ( !text_to_value (discrete_text, &discrete_val,
                              *write_spec))
            {
-             err_dialog(_("Incorrect value for variable type"),
+             err_dialog (_("Incorrect value for variable type"),
                         GTK_WINDOW(dialog->window) );
-             g_free(discrete_text);
+             g_free (discrete_text);
              return;
            }
-         mv_add_value(&dialog->mvl, &discrete_val);
+         mv_add_value (&dialog->mvl, &discrete_val);
        }
-      g_free(discrete_text);
+      g_free (discrete_text);
     }
 
 
-  if (gtk_toggle_button_get_active(dialog->button_none))
-    mv_clear(&dialog->mvl);
+  if (gtk_toggle_button_get_active (dialog->button_none))
+    mv_clear (&dialog->mvl);
 
   var_set_missing_values (dialog->pv, &dialog->mvl);
 
@@ -181,75 +181,75 @@ missing_val_dialog_accept(GtkWidget *w, gpointer data)
 
 /* Callback which occurs when the 'discrete' radiobutton is toggled */
 static void
-discrete(GtkToggleButton *button, gpointer data)
+discrete (GtkToggleButton *button, gpointer data)
 {
   gint i;
   struct missing_val_dialog *dialog = data;
 
-  for(i = 0 ; i < 3 ; ++i )
+  for (i = 0 ; i < 3 ; ++i )
     {
-      gtk_widget_set_sensitive(dialog->mv[i],
-                              gtk_toggle_button_get_active(button));
+      gtk_widget_set_sensitive (dialog->mv[i],
+                              gtk_toggle_button_get_active (button));
     }
 }
 
 /* Callback which occurs when the 'range' radiobutton is toggled */
 static void
-range(GtkToggleButton *button, gpointer data)
+range (GtkToggleButton *button, gpointer data)
 {
   struct missing_val_dialog *dialog = data;
 
   const gboolean active = gtk_toggle_button_get_active (button);
 
-  gtk_widget_set_sensitive(dialog->low, active);
-  gtk_widget_set_sensitive(dialog->high, active);
-  gtk_widget_set_sensitive(dialog->discrete, active);
+  gtk_widget_set_sensitive (dialog->low, active);
+  gtk_widget_set_sensitive (dialog->high, active);
+  gtk_widget_set_sensitive (dialog->discrete, active);
 }
 
 
 /* Creates the dialog structure from the xml */
 struct missing_val_dialog *
-missing_val_dialog_create(GladeXML *xml)
+missing_val_dialog_create (GladeXML *xml)
 {
-  struct missing_val_dialog *dialog = g_malloc(sizeof(*dialog));
+  struct missing_val_dialog *dialog = g_malloc (sizeof (*dialog));
 
-  dialog->window = get_widget_assert(xml, "missing_values_dialog");
+  dialog->window = get_widget_assert (xml, "missing_values_dialog");
 
   gtk_window_set_transient_for
     (GTK_WINDOW(dialog->window),
-     GTK_WINDOW(get_widget_assert(xml, "data_editor")));
+     GTK_WINDOW(get_widget_assert (xml, "data_editor")));
 
 
-  g_signal_connect_swapped(get_widget_assert(xml, "missing_val_cancel"),
+  g_signal_connect_swapped (get_widget_assert (xml, "missing_val_cancel"),
                   "clicked", G_CALLBACK(gtk_widget_hide), dialog->window);
 
-  g_signal_connect(get_widget_assert(xml, "missing_val_ok"),
+  g_signal_connect (get_widget_assert (xml, "missing_val_ok"),
                   "clicked", G_CALLBACK(missing_val_dialog_accept), dialog);
 
 
-  dialog->mv[0] = get_widget_assert(xml, "mv0");
-  dialog->mv[1] = get_widget_assert(xml, "mv1");
-  dialog->mv[2] = get_widget_assert(xml, "mv2");
+  dialog->mv[0] = get_widget_assert (xml, "mv0");
+  dialog->mv[1] = get_widget_assert (xml, "mv1");
+  dialog->mv[2] = get_widget_assert (xml, "mv2");
 
-  dialog->low = get_widget_assert(xml, "mv-low");
-  dialog->high = get_widget_assert(xml, "mv-high");
-  dialog->discrete = get_widget_assert(xml, "mv-discrete");
+  dialog->low = get_widget_assert (xml, "mv-low");
+  dialog->high = get_widget_assert (xml, "mv-high");
+  dialog->discrete = get_widget_assert (xml, "mv-discrete");
 
 
   dialog->button_none     =
-    GTK_TOGGLE_BUTTON(get_widget_assert(xml, "no_missing"));
+    GTK_TOGGLE_BUTTON(get_widget_assert (xml, "no_missing"));
 
   dialog->button_discrete =
-    GTK_TOGGLE_BUTTON(get_widget_assert(xml, "discrete_missing"));
+    GTK_TOGGLE_BUTTON(get_widget_assert (xml, "discrete_missing"));
 
   dialog->button_range    =
-    GTK_TOGGLE_BUTTON(get_widget_assert(xml, "range_missing"));
+    GTK_TOGGLE_BUTTON(get_widget_assert (xml, "range_missing"));
 
 
-  g_signal_connect(G_OBJECT(dialog->button_discrete), "toggled",
+  g_signal_connect (G_OBJECT(dialog->button_discrete), "toggled",
                   G_CALLBACK(discrete), dialog);
 
-  g_signal_connect(G_OBJECT(dialog->button_range), "toggled",
+  g_signal_connect (G_OBJECT(dialog->button_range), "toggled",
                   G_CALLBACK(range), dialog);
 
   return dialog;
@@ -257,34 +257,34 @@ missing_val_dialog_create(GladeXML *xml)
 
 /* Shows the dialog box and sets default values */
 void
-missing_val_dialog_show(struct missing_val_dialog *dialog)
+missing_val_dialog_show (struct missing_val_dialog *dialog)
 {
   const struct fmt_spec *write_spec ;
 
   gint i;
-  g_return_if_fail(dialog);
-  g_return_if_fail(dialog->pv);
+  g_return_if_fail (dialog);
+  g_return_if_fail (dialog->pv);
 
   mv_copy (&dialog->mvl, var_get_missing_values (dialog->pv));
 
   write_spec = var_get_write_format (dialog->pv);
 
   /* Blank all entry boxes and make them insensitive */
-  gtk_entry_set_text(GTK_ENTRY(dialog->low), "");
-  gtk_entry_set_text(GTK_ENTRY(dialog->high), "");
-  gtk_entry_set_text(GTK_ENTRY(dialog->discrete), "");
-  gtk_widget_set_sensitive(dialog->low, FALSE);
-  gtk_widget_set_sensitive(dialog->high, FALSE);
-  gtk_widget_set_sensitive(dialog->discrete, FALSE);
-
-  gtk_widget_set_sensitive(GTK_WIDGET(dialog->button_range),
+  gtk_entry_set_text (GTK_ENTRY(dialog->low), "");
+  gtk_entry_set_text (GTK_ENTRY(dialog->high), "");
+  gtk_entry_set_text (GTK_ENTRY(dialog->discrete), "");
+  gtk_widget_set_sensitive (dialog->low, FALSE);
+  gtk_widget_set_sensitive (dialog->high, FALSE);
+  gtk_widget_set_sensitive (dialog->discrete, FALSE);
+
+  gtk_widget_set_sensitive (GTK_WIDGET(dialog->button_range),
                           var_is_numeric (dialog->pv));
 
 
-  for(i = 0 ; i < 3 ; ++i )
+  for (i = 0 ; i < 3 ; ++i )
     {
-      gtk_entry_set_text(GTK_ENTRY(dialog->mv[i]), "");
-      gtk_widget_set_sensitive(dialog->mv[i], FALSE);
+      gtk_entry_set_text (GTK_ENTRY(dialog->mv[i]), "");
+      gtk_widget_set_sensitive (dialog->mv[i], FALSE);
     }
 
   if ( mv_has_range (&dialog->mvl))
@@ -292,56 +292,56 @@ missing_val_dialog_show(struct missing_val_dialog *dialog)
       union value low, high;
       gchar *low_text;
       gchar *high_text;
-      mv_peek_range(&dialog->mvl, &low.f, &high.f);
+      mv_peek_range (&dialog->mvl, &low.f, &high.f);
 
-      low_text = value_to_text(low, *write_spec);
-      high_text = value_to_text(high, *write_spec);
+      low_text = value_to_text (low, *write_spec);
+      high_text = value_to_text (high, *write_spec);
 
-      gtk_entry_set_text(GTK_ENTRY(dialog->low), low_text);
-      gtk_entry_set_text(GTK_ENTRY(dialog->high), high_text);
-      g_free(low_text);
-      g_free(high_text);
+      gtk_entry_set_text (GTK_ENTRY(dialog->low), low_text);
+      gtk_entry_set_text (GTK_ENTRY(dialog->high), high_text);
+      g_free (low_text);
+      g_free (high_text);
 
-      if ( mv_has_value(&dialog->mvl))
+      if ( mv_has_value (&dialog->mvl))
        {
          gchar *text;
          union value value;
-         mv_peek_value(&dialog->mvl, &value, 0);
-         text = value_to_text(value, *write_spec);
-         gtk_entry_set_text(GTK_ENTRY(dialog->discrete), text);
-         g_free(text);
+         mv_peek_value (&dialog->mvl, &value, 0);
+         text = value_to_text (value, *write_spec);
+         gtk_entry_set_text (GTK_ENTRY(dialog->discrete), text);
+         g_free (text);
        }
 
-      gtk_toggle_button_set_active(dialog->button_range, TRUE);
-      gtk_widget_set_sensitive(dialog->low, TRUE);
-      gtk_widget_set_sensitive(dialog->high, TRUE);
-      gtk_widget_set_sensitive(dialog->discrete, TRUE);
+      gtk_toggle_button_set_active (dialog->button_range, TRUE);
+      gtk_widget_set_sensitive (dialog->low, TRUE);
+      gtk_widget_set_sensitive (dialog->high, TRUE);
+      gtk_widget_set_sensitive (dialog->discrete, TRUE);
 
     }
   else if ( mv_has_value (&dialog->mvl))
     {
       const int n = mv_n_values (&dialog->mvl);
 
-      for(i = 0 ; i < 3 ; ++i )
+      for (i = 0 ; i < 3 ; ++i )
        {
          if ( i < n)
            {
              gchar *text ;
              union value value;
 
-             mv_peek_value(&dialog->mvl, &value, i);
-             text = value_to_text(value, *write_spec);
-             gtk_entry_set_text(GTK_ENTRY(dialog->mv[i]), text);
-             g_free(text);
+             mv_peek_value (&dialog->mvl, &value, i);
+             text = value_to_text (value, *write_spec);
+             gtk_entry_set_text (GTK_ENTRY(dialog->mv[i]), text);
+             g_free (text);
            }
-         gtk_widget_set_sensitive(dialog->mv[i], TRUE);
+         gtk_widget_set_sensitive (dialog->mv[i], TRUE);
        }
-      gtk_toggle_button_set_active(dialog->button_discrete, TRUE);
+      gtk_toggle_button_set_active (dialog->button_discrete, TRUE);
     }
   else if ( mv_is_empty (&dialog->mvl))
     {
-      gtk_toggle_button_set_active(dialog->button_none, TRUE);
+      gtk_toggle_button_set_active (dialog->button_none, TRUE);
     }
 
-  gtk_widget_show(dialog->window);
+  gtk_widget_show (dialog->window);
 }
index 3ca852af9dd17bd3a923ddfec5b6fbed49bfb042..39cbe2758e8785d6d117cf20d36f22b2ee952519 100644 (file)
@@ -51,8 +51,8 @@ struct missing_val_dialog
   GtkWidget *discrete;
 };
 
-struct missing_val_dialog * missing_val_dialog_create(GladeXML *xml);
+struct missing_val_dialog * missing_val_dialog_create (GladeXML *xml);
 
-void missing_val_dialog_show(struct missing_val_dialog *dialog);
+void missing_val_dialog_show (struct missing_val_dialog *dialog);
 
 #endif
index 6c7942f551a0bfe34e86bd80c6d7b190c1098e8e..cadcffd758b920dc17788de68d216109b94c7ee8 100644 (file)
@@ -134,7 +134,7 @@ psppire_case_file_finalize (GObject *object)
   PsppireCaseFile *cf = PSPPIRE_CASE_FILE (object);
 
   if ( cf->flexifile)
-    casefile_destroy(cf->flexifile);
+    casefile_destroy (cf->flexifile);
 
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
@@ -181,37 +181,37 @@ psppire_case_file_new_from_flexifile (struct flexifile *ff)
 
 
 gboolean
-psppire_case_file_delete_cases(PsppireCaseFile *cf, gint n_cases, gint first)
+psppire_case_file_delete_cases (PsppireCaseFile *cf, gint n_cases, gint first)
 {
   int result;
 
-  g_return_val_if_fail(cf, FALSE);
-  g_return_val_if_fail(cf->flexifile, FALSE);
+  g_return_val_if_fail (cf, FALSE);
+  g_return_val_if_fail (cf->flexifile, FALSE);
 
-  result =  flexifile_delete_cases(FLEXIFILE(cf->flexifile), n_cases,  first);
+  result =  flexifile_delete_cases (FLEXIFILE(cf->flexifile), n_cases,  first);
 
-  g_signal_emit(cf, signal[CASES_DELETED], 0, n_cases, first);
+  g_signal_emit (cf, signal[CASES_DELETED], 0, n_cases, first);
 
   return result;
 }
 
 /* Insert case CC into the case file before POSN */
 gboolean
-psppire_case_file_insert_case(PsppireCaseFile *cf,
+psppire_case_file_insert_case (PsppireCaseFile *cf,
                              struct ccase *cc,
                              gint posn)
 {
   bool result ;
 
-  g_return_val_if_fail(cf, FALSE);
-  g_return_val_if_fail(cf->flexifile, FALSE);
+  g_return_val_if_fail (cf, FALSE);
+  g_return_val_if_fail (cf->flexifile, FALSE);
 
-  result = flexifile_insert_case(FLEXIFILE(cf->flexifile), cc, posn);
+  result = flexifile_insert_case (FLEXIFILE(cf->flexifile), cc, posn);
 
   if ( result )
-    g_signal_emit(cf, signal[CASE_INSERTED], 0, posn);
+    g_signal_emit (cf, signal[CASE_INSERTED], 0, posn);
   else
-    g_warning("Cannot insert case at position %d\n", posn);
+    g_warning ("Cannot insert case at position %d\n", posn);
 
   return result;
 }
@@ -219,80 +219,80 @@ psppire_case_file_insert_case(PsppireCaseFile *cf,
 
 /* Append a case to the case file */
 gboolean
-psppire_case_file_append_case(PsppireCaseFile *cf,
+psppire_case_file_append_case (PsppireCaseFile *cf,
                              struct ccase *c)
 {
   bool result ;
   gint posn ;
 
-  g_return_val_if_fail(cf, FALSE);
-  g_return_val_if_fail(cf->flexifile, FALSE);
+  g_return_val_if_fail (cf, FALSE);
+  g_return_val_if_fail (cf->flexifile, FALSE);
 
-  posn = casefile_get_case_cnt(cf->flexifile);
+  posn = casefile_get_case_cnt (cf->flexifile);
 
-  result = casefile_append(cf->flexifile, c);
+  result = casefile_append (cf->flexifile, c);
 
-  g_signal_emit(cf, signal[CASE_INSERTED], 0, posn);
+  g_signal_emit (cf, signal[CASE_INSERTED], 0, posn);
 
   return result;
 }
 
 
 inline gint
-psppire_case_file_get_case_count(const PsppireCaseFile *cf)
+psppire_case_file_get_case_count (const PsppireCaseFile *cf)
 {
-  g_return_val_if_fail(cf, FALSE);
+  g_return_val_if_fail (cf, FALSE);
 
   if ( ! cf->flexifile)
     return 0;
 
-  return casefile_get_case_cnt(cf->flexifile);
+  return casefile_get_case_cnt (cf->flexifile);
 }
 
 /* Return the IDXth value from case CASENUM.
    The return value must not be freed or written to
  */
 const union value *
-psppire_case_file_get_value(const PsppireCaseFile *cf, gint casenum, gint idx)
+psppire_case_file_get_value (const PsppireCaseFile *cf, gint casenum, gint idx)
 {
   const union value *v;
   struct ccase c;
 
-  g_return_val_if_fail(cf, NULL);
-  g_return_val_if_fail(cf->flexifile, NULL);
+  g_return_val_if_fail (cf, NULL);
+  g_return_val_if_fail (cf->flexifile, NULL);
 
-  g_return_val_if_fail(idx < casefile_get_value_cnt(cf->flexifile), NULL);
+  g_return_val_if_fail (idx < casefile_get_value_cnt (cf->flexifile), NULL);
 
-  flexifile_get_case(FLEXIFILE(cf->flexifile), casenum, &c);
+  flexifile_get_case (FLEXIFILE(cf->flexifile), casenum, &c);
 
-  v = case_data_idx(&c, idx);
-  case_destroy(&c);
+  v = case_data_idx (&c, idx);
+  case_destroy (&c);
 
   return v;
 }
 
 void
-psppire_case_file_clear(PsppireCaseFile *cf)
+psppire_case_file_clear (PsppireCaseFile *cf)
 {
-  casefile_destroy(cf->flexifile);
+  casefile_destroy (cf->flexifile);
   cf->flexifile = 0;
-  g_signal_emit(cf, signal[CASES_DELETED], 0, 0, -1);
+  g_signal_emit (cf, signal[CASES_DELETED], 0, 0, -1);
 }
 
 /* Set the IDXth value of case C to SYSMIS/EMPTY */
 gboolean
-psppire_case_file_set_value(PsppireCaseFile *cf, gint casenum, gint idx,
+psppire_case_file_set_value (PsppireCaseFile *cf, gint casenum, gint idx,
                            union value *v, gint width)
 {
   struct ccase cc ;
   int bytes;
 
-  g_return_val_if_fail(cf, FALSE);
-  g_return_val_if_fail(cf->flexifile, FALSE);
+  g_return_val_if_fail (cf, FALSE);
+  g_return_val_if_fail (cf->flexifile, FALSE);
 
-  g_return_val_if_fail(idx < casefile_get_value_cnt(cf->flexifile), FALSE);
+  g_return_val_if_fail (idx < casefile_get_value_cnt (cf->flexifile), FALSE);
 
-  if ( ! flexifile_get_case(FLEXIFILE(cf->flexifile), casenum, &cc) )
+  if ( ! flexifile_get_case (FLEXIFILE(cf->flexifile), casenum, &cc) )
     return FALSE;
 
   if ( width == 0 )
@@ -301,9 +301,9 @@ psppire_case_file_set_value(PsppireCaseFile *cf, gint casenum, gint idx,
     bytes = DIV_RND_UP(width, MAX_SHORT_STRING) * MAX_SHORT_STRING ;
 
   /* Cast away const in flagrant abuse of the casefile */
-  memcpy((union value *)case_data_idx(&cc, idx), v, bytes);
+  memcpy ((union value *)case_data_idx (&cc, idx), v, bytes);
 
-  g_signal_emit(cf, signal[CASE_CHANGED], 0, casenum);
+  g_signal_emit (cf, signal[CASE_CHANGED], 0, casenum);
 
   return TRUE;
 }
@@ -312,32 +312,32 @@ psppire_case_file_set_value(PsppireCaseFile *cf, gint casenum, gint idx,
 
 /* Set the IDXth value of case C using D_IN */
 gboolean
-psppire_case_file_data_in(PsppireCaseFile *cf, gint casenum, gint idx,
+psppire_case_file_data_in (PsppireCaseFile *cf, gint casenum, gint idx,
                           struct substring input, const struct fmt_spec *fmt)
 {
   struct ccase cc ;
 
-  g_return_val_if_fail(cf, FALSE);
-  g_return_val_if_fail(cf->flexifile, FALSE);
+  g_return_val_if_fail (cf, FALSE);
+  g_return_val_if_fail (cf->flexifile, FALSE);
 
-  g_return_val_if_fail(idx < casefile_get_value_cnt(cf->flexifile), FALSE);
+  g_return_val_if_fail (idx < casefile_get_value_cnt (cf->flexifile), FALSE);
 
-  if ( ! flexifile_get_case(FLEXIFILE(cf->flexifile), casenum, &cc) )
+  if ( ! flexifile_get_case (FLEXIFILE(cf->flexifile), casenum, &cc) )
     return FALSE;
 
   /* Cast away const in flagrant abuse of the casefile */
   if (!data_in (input, fmt->type, 0, 0,
-                (union value *) case_data_idx(&cc, idx), fmt_var_width (fmt)))
-    g_warning("Cant set value\n");
+                (union value *) case_data_idx (&cc, idx), fmt_var_width (fmt)))
+    g_warning ("Cant set value\n");
 
-  g_signal_emit(cf, signal[CASE_CHANGED], 0, casenum);
+  g_signal_emit (cf, signal[CASE_CHANGED], 0, casenum);
 
   return TRUE;
 }
 
 
 void
-psppire_case_file_sort(PsppireCaseFile *cf, const struct sort_criteria *sc)
+psppire_case_file_sort (PsppireCaseFile *cf, const struct sort_criteria *sc)
 {
   gint c;
 
@@ -346,16 +346,16 @@ psppire_case_file_sort(PsppireCaseFile *cf, const struct sort_criteria *sc)
 
   struct casefile_factory *factory  = flexifile_factory_create ();
 
-  cfile = sort_execute(reader, sc, factory);
+  cfile = sort_execute (reader, sc, factory);
 
-  casefile_destroy(cf->flexifile);
+  casefile_destroy (cf->flexifile);
 
   cf->flexifile = cfile;
 
   /* FIXME: Need to have a signal to change a range of cases, instead of
      calling a signal many times */
-  for ( c = 0 ; c < casefile_get_case_cnt(cf->flexifile) ; ++c )
-    g_signal_emit(cf, signal[CASE_CHANGED], 0, c);
+  for ( c = 0 ; c < casefile_get_case_cnt (cf->flexifile) ; ++c )
+    g_signal_emit (cf, signal[CASE_CHANGED], 0, c);
 
   flexifile_factory_destroy (factory);
 }
@@ -367,11 +367,11 @@ gboolean
 psppire_case_file_insert_values (PsppireCaseFile *cf,
                                 gint n_values, gint before)
 {
-  g_return_val_if_fail(cf, FALSE);
+  g_return_val_if_fail (cf, FALSE);
 
   if ( ! cf->flexifile )
     {
-      cf->flexifile = flexifile_create(n_values);
+      cf->flexifile = flexifile_create (n_values);
 
       return TRUE;
     }
index 878fc4744ce5a9ce708e8634cfbf13bc7715a48a..478f935afbcbd251ac3c8cee4802f1c5319b86a2 100644 (file)
@@ -72,35 +72,35 @@ PsppireCaseFile *psppire_case_file_new (gint var_cnt);
 PsppireCaseFile* psppire_case_file_new_from_flexifile (struct flexifile *ff);
 
 
-gboolean psppire_case_file_insert_case(PsppireCaseFile *cf, struct ccase *c, gint row);
+gboolean psppire_case_file_insert_case (PsppireCaseFile *cf, struct ccase *c, gint row);
 
-gint psppire_case_file_get_case_count(const PsppireCaseFile *cf);
+gint psppire_case_file_get_case_count (const PsppireCaseFile *cf);
 
 
-const union value * psppire_case_file_get_value(const PsppireCaseFile *cf,
+const union value * psppire_case_file_get_value (const PsppireCaseFile *cf,
                                              gint c, gint idx);
 
 struct fmt_spec;
 
-gboolean psppire_case_file_data_in(PsppireCaseFile *cf, gint c, gint idx,
+gboolean psppire_case_file_data_in (PsppireCaseFile *cf, gint c, gint idx,
                                    struct substring input,
                                    const struct fmt_spec *);
 
-gboolean psppire_case_file_set_value(PsppireCaseFile *cf, gint casenum,
+gboolean psppire_case_file_set_value (PsppireCaseFile *cf, gint casenum,
                                     gint idx, union value *v, gint width);
 
-void psppire_case_file_clear(PsppireCaseFile *cf);
+void psppire_case_file_clear (PsppireCaseFile *cf);
 
 
-gboolean psppire_case_file_delete_cases(PsppireCaseFile *cf, gint n_rows,
+gboolean psppire_case_file_delete_cases (PsppireCaseFile *cf, gint n_rows,
                                        gint first);
 
-gboolean psppire_case_file_insert_values(PsppireCaseFile *cf, gint n_values, gint before);
+gboolean psppire_case_file_insert_values (PsppireCaseFile *cf, gint n_values, gint before);
 
 struct sort_criteria;
-void psppire_case_file_sort(PsppireCaseFile *cf, const struct sort_criteria *);
+void psppire_case_file_sort (PsppireCaseFile *cf, const struct sort_criteria *);
 
-gboolean psppire_case_file_get_case(const PsppireCaseFile *cf, gint casenum,
+gboolean psppire_case_file_get_case (const PsppireCaseFile *cf, gint casenum,
                                    struct ccase *c);
 
 
index 30d0cbd3e6e53d4aaa83590a61cd3157b1c73f74..9e973ce349b21d3db4e514ed7a4c7ec3d576cd08 100644 (file)
@@ -22,7 +22,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <gettext.h>
-#define _(msgid) gettext(msgid)
+#define _(msgid) gettext (msgid)
 #define N_(msgid) msgid
 
 #include <data/casefile.h>
@@ -58,12 +58,12 @@ static void psppire_data_store_sheet_row_init (GSheetRowIface *iface);
 
 static void psppire_data_store_finalize        (GObject           *object);
 
-static gchar *psppire_data_store_get_string(const GSheetModel *sheet_model, gint row, gint column);
+static gchar *psppire_data_store_get_string (const GSheetModel *sheet_model, gint row, gint column);
 
-static gboolean psppire_data_store_set_string(GSheetModel *model,
+static gboolean psppire_data_store_set_string (GSheetModel *model,
                                          const gchar *text, gint row, gint column);
 
-static gboolean psppire_data_store_clear_datum(GSheetModel *model,
+static gboolean psppire_data_store_clear_datum (GSheetModel *model,
                                          gint row, gint column);
 
 
@@ -170,7 +170,7 @@ psppire_data_store_get_var_count (const GSheetModel *model)
 {
   const PsppireDataStore *store = PSPPIRE_DATA_STORE(model);
 
-  return psppire_dict_get_var_cnt(store->dict);
+  return psppire_dict_get_var_cnt (store->dict);
 }
 
 static gint
@@ -178,7 +178,7 @@ psppire_data_store_get_case_count (const GSheetModel *model)
 {
   const PsppireDataStore *store = PSPPIRE_DATA_STORE(model);
 
-  return psppire_case_file_get_case_count(store->case_file);
+  return psppire_case_file_get_case_count (store->case_file);
 }
 
 
@@ -191,7 +191,7 @@ psppire_data_store_init (PsppireDataStore *data_store)
 }
 
 const PangoFontDescription *
-psppire_data_store_get_font_desc(const GSheetModel *model,
+psppire_data_store_get_font_desc (const GSheetModel *model,
                              gint row, gint column)
 {
   PsppireDataStore *store = PSPPIRE_DATA_STORE(model);
@@ -218,14 +218,14 @@ psppire_data_store_sheet_model_init (GSheetModelIface *iface)
 }
 
 static
-gboolean always_true()
+gboolean always_true ()
 {
   return TRUE;
 }
 
 
 static void
-delete_cases_callback(GtkWidget *w, gint first, gint n_cases, gpointer data)
+delete_cases_callback (GtkWidget *w, gint first, gint n_cases, gpointer data)
 {
   PsppireDataStore *store  ;
 
@@ -233,14 +233,14 @@ delete_cases_callback(GtkWidget *w, gint first, gint n_cases, gpointer data)
 
   store  = PSPPIRE_DATA_STORE(data);
 
-  g_assert(first >= 0);
+  g_assert (first >= 0);
 
   g_sheet_model_rows_deleted (G_SHEET_MODEL(store), first, n_cases);
 }
 
 
 static void
-insert_case_callback(GtkWidget *w, gint casenum, gpointer data)
+insert_case_callback (GtkWidget *w, gint casenum, gpointer data)
 {
   PsppireDataStore *store  ;
 
@@ -250,7 +250,7 @@ insert_case_callback(GtkWidget *w, gint casenum, gpointer data)
 
   g_sheet_model_range_changed (G_SHEET_MODEL(store),
                               casenum, -1,
-                              psppire_case_file_get_case_count(store->case_file),
+                              psppire_case_file_get_case_count (store->case_file),
                               -1);
 
   g_sheet_model_rows_inserted (G_SHEET_MODEL(store), casenum, 1);
@@ -258,7 +258,7 @@ insert_case_callback(GtkWidget *w, gint casenum, gpointer data)
 
 
 static void
-changed_case_callback(GtkWidget *w, gint casenum, gpointer data)
+changed_case_callback (GtkWidget *w, gint casenum, gpointer data)
 {
   PsppireDataStore *store  ;
   g_return_if_fail (data);
@@ -272,7 +272,7 @@ changed_case_callback(GtkWidget *w, gint casenum, gpointer data)
 
 
 static void
-delete_variables_callback(GObject *obj, gint var_num, gint n_vars, gpointer data)
+delete_variables_callback (GObject *obj, gint var_num, gint n_vars, gpointer data)
 {
   PsppireDataStore *store ;
 
@@ -282,12 +282,12 @@ delete_variables_callback(GObject *obj, gint var_num, gint n_vars, gpointer data
 
   g_sheet_model_columns_deleted (G_SHEET_MODEL(store), var_num, n_vars);
 
-  g_sheet_column_columns_changed(G_SHEET_COLUMN(store),
+  g_sheet_column_columns_changed (G_SHEET_COLUMN(store),
                                   var_num, -1);
 }
 
 static void
-insert_variable_callback(GObject *obj, gint var_num, gpointer data)
+insert_variable_callback (GObject *obj, gint var_num, gpointer data)
 {
   PsppireDataStore *store;
   gint posn;
@@ -299,7 +299,7 @@ insert_variable_callback(GObject *obj, gint var_num, gpointer data)
   if ( var_num > 0 )
     {
       struct variable *variable;
-      variable = psppire_dict_get_variable(store->dict, var_num);
+      variable = psppire_dict_get_variable (store->dict, var_num);
 
       posn = var_get_case_index (variable);
     }
@@ -308,9 +308,9 @@ insert_variable_callback(GObject *obj, gint var_num, gpointer data)
       posn = 0;
     }
 
-  psppire_case_file_insert_values(store->case_file, 1, posn);
+  psppire_case_file_insert_values (store->case_file, 1, posn);
 
-  g_sheet_column_columns_changed(G_SHEET_COLUMN(store),
+  g_sheet_column_columns_changed (G_SHEET_COLUMN(store),
                                  var_num, 1);
 
   g_sheet_model_columns_inserted (G_SHEET_MODEL(store), var_num, 1);
@@ -318,7 +318,7 @@ insert_variable_callback(GObject *obj, gint var_num, gpointer data)
 
 
 static void
-dict_size_change_callback(GObject *obj,
+dict_size_change_callback (GObject *obj,
                          gint posn, gint adjustment, gpointer data)
 {
   PsppireDataStore *store ;
@@ -346,7 +346,7 @@ psppire_data_store_new (PsppireDict *dict)
 
   retval = g_object_new (GTK_TYPE_DATA_STORE, NULL);
 
-  psppire_data_store_set_dictionary(retval, dict);
+  psppire_data_store_set_dictionary (retval, dict);
 
 
   return retval;
@@ -363,38 +363,38 @@ psppire_data_store_new (PsppireDict *dict)
  * destroyed.
  **/
 void
-psppire_data_store_set_dictionary(PsppireDataStore *data_store, PsppireDict *dict)
+psppire_data_store_set_dictionary (PsppireDataStore *data_store, PsppireDict *dict)
 {
-  gint var_cnt = psppire_dict_get_next_value_idx(dict);
+  gint var_cnt = psppire_dict_get_next_value_idx (dict);
 
   data_store->dict = dict;
 
   if ( data_store->case_file)
     {
-      g_object_unref(data_store->case_file);
+      g_object_unref (data_store->case_file);
       data_store->case_file = 0;
     }
 
-  data_store->case_file = psppire_case_file_new(var_cnt);
+  data_store->case_file = psppire_case_file_new (var_cnt);
 
-  g_signal_connect(data_store->case_file, "cases-deleted",
+  g_signal_connect (data_store->case_file, "cases-deleted",
                   G_CALLBACK(delete_cases_callback),
                   data_store);
 
-  g_signal_connect(data_store->case_file, "case-inserted",
+  g_signal_connect (data_store->case_file, "case-inserted",
                   G_CALLBACK(insert_case_callback),
                   data_store);
 
 
-  g_signal_connect(data_store->case_file, "case-changed",
+  g_signal_connect (data_store->case_file, "case-changed",
                   G_CALLBACK(changed_case_callback),
                   data_store);
 
-  g_signal_connect(dict, "variable-inserted",
+  g_signal_connect (dict, "variable-inserted",
                   G_CALLBACK(insert_variable_callback),
                   data_store);
 
-  g_signal_connect(dict, "variables-deleted",
+  g_signal_connect (dict, "variables-deleted",
                   G_CALLBACK(delete_variables_callback),
                   data_store);
 
@@ -405,7 +405,7 @@ psppire_data_store_set_dictionary(PsppireDataStore *data_store, PsppireDict *dic
   /* The entire model has changed */
   g_sheet_model_range_changed (G_SHEET_MODEL(data_store), -1, -1, -1, -1);
 
-  g_sheet_column_columns_changed(G_SHEET_COLUMN(data_store), 0, -1);
+  g_sheet_column_columns_changed (G_SHEET_COLUMN(data_store), 0, -1);
 }
 
 static void
@@ -420,7 +420,7 @@ psppire_data_store_finalize (GObject *object)
 
 /* Insert a blank case before POSN */
 gboolean
-psppire_data_store_insert_new_case(PsppireDataStore *ds, gint posn)
+psppire_data_store_insert_new_case (PsppireDataStore *ds, gint posn)
 {
   gboolean result;
   gint val_cnt, v;
@@ -429,7 +429,7 @@ psppire_data_store_insert_new_case(PsppireDataStore *ds, gint posn)
 
 
   /* Opportunity for optimisation exists here when creating a blank case */
-  val_cnt = casefile_get_value_cnt(ds->case_file->flexifile) ;
+  val_cnt = casefile_get_value_cnt (ds->case_file->flexifile) ;
 
   case_create (&cc, val_cnt);
 
@@ -478,16 +478,16 @@ psppire_data_store_get_string (const GSheetModel *model, gint row, gint column)
 
   v = psppire_case_file_get_value (store->case_file, row, idx);
 
-  g_return_val_if_fail(v, NULL);
+  g_return_val_if_fail (v, NULL);
 
   if ( store->show_labels)
     {
       const struct val_labs * vl = var_get_value_labels (pv);
 
       const gchar *label;
-      if ( (label = val_labs_find(vl, *v)) )
+      if ( (label = val_labs_find (vl, *v)) )
        {
-         return pspp_locale_to_utf8(label, -1, 0);
+         return pspp_locale_to_utf8 (label, -1, 0);
        }
     }
 
@@ -529,9 +529,9 @@ psppire_data_store_clear_datum (GSheetModel *model,
   if ( var_is_numeric (pv))
     v.f = SYSMIS;
   else
-    memcpy(v.s, "", MAX_SHORT_STRING);
+    memcpy (v.s, "", MAX_SHORT_STRING);
 
-  psppire_case_file_set_value(store->case_file, row, index, &v,
+  psppire_case_file_set_value (store->case_file, row, index, &v,
                              var_get_width (pv));
 
   return TRUE;
@@ -543,26 +543,26 @@ psppire_data_store_clear_datum (GSheetModel *model,
    Returns true if anything was updated, false otherwise.
 */
 static gboolean
-psppire_data_store_set_string(GSheetModel *model,
+psppire_data_store_set_string (GSheetModel *model,
                          const gchar *text, gint row, gint col)
 {
   PsppireDataStore *store = PSPPIRE_DATA_STORE(model);
 
-  const struct variable *pv = psppire_dict_get_variable(store->dict, col);
-  g_return_val_if_fail(pv, FALSE);
+  const struct variable *pv = psppire_dict_get_variable (store->dict, col);
+  g_return_val_if_fail (pv, FALSE);
 
 #if 0
   /* Allow the user to insert a lot of blank cases, simply by skipping rows */
-  for(r = psppire_case_file_get_case_count(store->case_file); r <= row ; ++r)
+  for (r = psppire_case_file_get_case_count (store->case_file); r <= row ; ++r)
     {
 
       gint c;
 
-      psppire_case_array_insert_case(store->cases, r, 0, 0);
+      psppire_case_array_insert_case (store->cases, r, 0, 0);
 
 
-      for (c = 0 ; c < psppire_dict_get_var_cnt(store->dict); ++c )
-       psppire_data_store_clear_datum(model, r, c);
+      for (c = 0 ; c < psppire_dict_get_var_cnt (store->dict); ++c )
+       psppire_data_store_clear_datum (model, r, c);
     }
 #endif
 
@@ -575,7 +575,7 @@ psppire_data_store_set_string(GSheetModel *model,
 
 
 void
-psppire_data_store_set_font(PsppireDataStore *store,
+psppire_data_store_set_font (PsppireDataStore *store,
                            const PangoFontDescription *fd)
 {
   g_return_if_fail (store);
@@ -583,9 +583,9 @@ psppire_data_store_set_font(PsppireDataStore *store,
 
   store->font_desc = fd;
 #if 0
-  store->width_of_m = calc_m_width(fd);
+  store->width_of_m = calc_m_width (fd);
 #endif
-  g_signal_emit(store, signal[FONT_CHANGED], 0);
+  g_signal_emit (store, signal[FONT_CHANGED], 0);
 
 
   g_sheet_model_range_changed (G_SHEET_MODEL(store),
@@ -594,7 +594,7 @@ psppire_data_store_set_font(PsppireDataStore *store,
 
 
 void
-psppire_data_store_show_labels(PsppireDataStore *store, gboolean show_labels)
+psppire_data_store_show_labels (PsppireDataStore *store, gboolean show_labels)
 {
   g_return_if_fail (store);
   g_return_if_fail (PSPPIRE_IS_DATA_STORE (store));
@@ -610,7 +610,7 @@ psppire_data_store_show_labels(PsppireDataStore *store, gboolean show_labels)
 /* FIXME: There's no reason to actually have this function.
    It should be done by a procedure */
 void
-psppire_data_store_create_system_file(PsppireDataStore *store,
+psppire_data_store_create_system_file (PsppireDataStore *store,
                              struct file_handle *handle)
 {
   gint i, var_cnt;
@@ -622,9 +622,9 @@ psppire_data_store_create_system_file(PsppireDataStore *store,
 
   struct sfm_writer *writer ;
 
-  g_assert(handle);
+  g_assert (handle);
 
-  writer = sfm_open_writer(handle, store->dict->dict, wo);
+  writer = sfm_open_writer (handle, store->dict->dict, wo);
 
   if ( ! writer)
     return;
@@ -632,7 +632,7 @@ psppire_data_store_create_system_file(PsppireDataStore *store,
 
   var_cnt = psppire_data_store_get_var_count (G_SHEET_MODEL(store));
 
-  for (i = 0 ; i < psppire_case_file_get_case_count(store->case_file); ++i )
+  for (i = 0 ; i < psppire_case_file_get_case_count (store->case_file); ++i )
     {
       struct ccase c;
 
@@ -643,17 +643,17 @@ psppire_data_store_create_system_file(PsppireDataStore *store,
       case_destroy (&c);
     }
 
-  sfm_close_writer(writer);
+  sfm_close_writer (writer);
 }
 
 
 
 void
-psppire_data_store_clear(PsppireDataStore *data_store)
+psppire_data_store_clear (PsppireDataStore *data_store)
 {
-  psppire_case_file_clear(data_store->case_file);
+  psppire_case_file_clear (data_store->case_file);
 
-  psppire_dict_clear(data_store->dict);
+  psppire_dict_clear (data_store->dict);
 }
 
 
@@ -662,22 +662,22 @@ psppire_data_store_clear(PsppireDataStore *data_store)
 /* Column related funcs */
 
 static gint
-geometry_get_column_count(const GSheetColumn *geom)
+geometry_get_column_count (const GSheetColumn *geom)
 {
   PsppireDataStore *ds = PSPPIRE_DATA_STORE(geom);
 
-  return MAX(MIN_COLUMNS, psppire_dict_get_var_cnt(ds->dict));
+  return MAX(MIN_COLUMNS, psppire_dict_get_var_cnt (ds->dict));
 }
 
 
 
 static gint
-geometry_get_width(const GSheetColumn *geom, gint unit)
+geometry_get_width (const GSheetColumn *geom, gint unit)
 {
   const struct variable *pv ;
   PsppireDataStore *ds = PSPPIRE_DATA_STORE(geom);
 
-  if ( unit >= psppire_dict_get_var_cnt(ds->dict) )
+  if ( unit >= psppire_dict_get_var_cnt (ds->dict) )
     return ds->width_of_m * 8 ;
 
   pv = psppire_dict_get_variable (ds->dict, unit);
@@ -689,7 +689,7 @@ geometry_get_width(const GSheetColumn *geom, gint unit)
 }
 
 static void
-geometry_set_width(GSheetColumn *geom, gint unit, gint width)
+geometry_set_width (GSheetColumn *geom, gint unit, gint width)
 {
   PsppireDataStore *ds = PSPPIRE_DATA_STORE(geom);
 
@@ -701,16 +701,16 @@ geometry_set_width(GSheetColumn *geom, gint unit, gint width)
 
 
 static GtkJustification
-geometry_get_justification(const GSheetColumn *geom, gint unit)
+geometry_get_justification (const GSheetColumn *geom, gint unit)
 {
   PsppireDataStore *ds = PSPPIRE_DATA_STORE(geom);
   const struct variable *pv ;
 
 
-  if ( unit >= psppire_dict_get_var_cnt(ds->dict) )
+  if ( unit >= psppire_dict_get_var_cnt (ds->dict) )
     return GTK_JUSTIFY_LEFT;
 
-  pv = psppire_dict_get_variable(ds->dict, unit);
+  pv = psppire_dict_get_variable (ds->dict, unit);
 
   return (var_get_alignment (pv) == ALIGN_LEFT ? GTK_JUSTIFY_LEFT
           : var_get_alignment (pv) == ALIGN_RIGHT ? GTK_JUSTIFY_RIGHT
@@ -721,14 +721,14 @@ geometry_get_justification(const GSheetColumn *geom, gint unit)
 static const gchar null_var_name[]=N_("var");
 
 static gchar *
-geometry_get_column_button_label(const GSheetColumn *geom, gint unit)
+geometry_get_column_button_label (const GSheetColumn *geom, gint unit)
 {
   gchar *text;
   struct variable *pv ;
   PsppireDataStore *ds = PSPPIRE_DATA_STORE(geom);
 
-  if ( unit >= psppire_dict_get_var_cnt(ds->dict) )
-    return g_locale_to_utf8(null_var_name, -1, 0, 0, 0);
+  if ( unit >= psppire_dict_get_var_cnt (ds->dict) )
+    return g_locale_to_utf8 (null_var_name, -1, 0, 0, 0);
 
   pv = psppire_dict_get_variable (ds->dict, unit);
 
@@ -739,11 +739,11 @@ geometry_get_column_button_label(const GSheetColumn *geom, gint unit)
 
 
 static gboolean
-geometry_get_sensitivity(const GSheetColumn *geom, gint unit)
+geometry_get_sensitivity (const GSheetColumn *geom, gint unit)
 {
   PsppireDataStore *ds = PSPPIRE_DATA_STORE(geom);
 
-  return (unit < psppire_dict_get_var_cnt(ds->dict));
+  return (unit < psppire_dict_get_var_cnt (ds->dict));
 }
 
 
@@ -763,47 +763,47 @@ psppire_data_store_sheet_column_init (GSheetColumnIface *iface)
 /* Row related funcs */
 
 static gint
-geometry_get_row_count(const GSheetRow *geom, gpointer data)
+geometry_get_row_count (const GSheetRow *geom, gpointer data)
 {
   PsppireDataStore *ds = PSPPIRE_DATA_STORE(geom);
 
-  return TRAILING_ROWS + psppire_case_file_get_case_count(ds->case_file);
+  return TRAILING_ROWS + psppire_case_file_get_case_count (ds->case_file);
 }
 
 
 static gint
-geometry_get_height(const GSheetRow *geom, gint unit, gpointer data)
+geometry_get_height (const GSheetRow *geom, gint unit, gpointer data)
 {
   return 25;
 }
 
 
 static gboolean
-geometry_get_row_sensitivity(const GSheetRow *geom, gint unit, gpointer data)
+geometry_get_row_sensitivity (const GSheetRow *geom, gint unit, gpointer data)
 {
   PsppireDataStore *ds = PSPPIRE_DATA_STORE(geom);
 
 
-  return (unit < psppire_case_file_get_case_count(ds->case_file));
+  return (unit < psppire_case_file_get_case_count (ds->case_file));
 }
 
 
 static gchar *
-geometry_get_row_button_label(const GSheetRow *geom, gint unit, gpointer data)
+geometry_get_row_button_label (const GSheetRow *geom, gint unit, gpointer data)
 {
   gchar *text;
   gchar *s;
   PsppireDataStore *ds = PSPPIRE_DATA_STORE(geom);
 
   if ( unit >
-       TRAILING_ROWS + psppire_case_file_get_case_count(ds->case_file))
+       TRAILING_ROWS + psppire_case_file_get_case_count (ds->case_file))
     return 0;
 
-  s = g_strdup_printf(_("%d"), unit);
+  s = g_strdup_printf (_("%d"), unit);
 
-  text =  pspp_locale_to_utf8(s, -1, 0);
+  text =  pspp_locale_to_utf8 (s, -1, 0);
 
-  g_free(s);
+  g_free (s);
 
   return text;
 }
index a828a88a14c9dedbd6a898a8c84da5017b9028a8..1974aed8ddb400e281ff76d7938bc9a9cf83d0ef 100644 (file)
@@ -84,16 +84,16 @@ struct _PsppireDataStoreClass
 inline GType psppire_data_store_get_type (void) G_GNUC_CONST;
 PsppireDataStore *psppire_data_store_new     (PsppireDict *dict);
 
-void psppire_data_store_set_dictionary(PsppireDataStore *data_store,
+void psppire_data_store_set_dictionary (PsppireDataStore *data_store,
                                       PsppireDict *dict);
 
-void psppire_data_store_set_font(PsppireDataStore *store,
+void psppire_data_store_set_font (PsppireDataStore *store,
                                 const PangoFontDescription *fd);
 
-void psppire_data_store_show_labels(PsppireDataStore *store,
+void psppire_data_store_show_labels (PsppireDataStore *store,
                                    gboolean show_labels);
 
-void psppire_data_store_clear(PsppireDataStore *data_store);
+void psppire_data_store_clear (PsppireDataStore *data_store);
 
 struct file_handle;
 
index 61337d24bbae7800017c52c91d2eeb0c755dc380..81bffe5cc9fa73623fbf491fb10663a82d51c3d8 100644 (file)
@@ -39,7 +39,7 @@ static void psppire_dict_class_init   (PsppireDictClass       *class);
 static void psppire_dict_init  (PsppireDict            *dict);
 static void psppire_dict_finalize      (GObject                *object);
 
-static void dictionary_tree_model_init(GtkTreeModelIface *iface);
+static void dictionary_tree_model_init (GtkTreeModelIface *iface);
 
 
 /* --- variables --- */
@@ -89,7 +89,7 @@ psppire_dict_get_type (void)
                                            "PsppireDict",
                                            &object_info, 0);
 
-      g_type_add_interface_static(object_type, GTK_TYPE_TREE_MODEL,
+      g_type_add_interface_static (object_type, GTK_TYPE_TREE_MODEL,
                                  &tree_model_info);
 
 
@@ -165,7 +165,7 @@ psppire_dict_finalize (GObject *object)
 {
   PsppireDict *d = PSPPIRE_DICT (object);
 
-  dict_destroy(d->dict);
+  dict_destroy (d->dict);
 
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
@@ -175,19 +175,19 @@ psppire_dict_finalize (GObject *object)
 static void
 addcb (struct dictionary *d, int idx, void *pd)
 {
-  g_signal_emit(pd, signal[VARIABLE_INSERTED], 0, idx);
+  g_signal_emit (pd, signal[VARIABLE_INSERTED], 0, idx);
 }
 
 static void
 delcb (struct dictionary *d, int idx, void *pd)
 {
-  g_signal_emit(pd, signal[VARIABLES_DELETED], 0, idx, 1);
+  g_signal_emit (pd, signal[VARIABLES_DELETED], 0, idx, 1);
 }
 
 static void
 mutcb (struct dictionary *d, int idx, void *pd)
 {
-  g_signal_emit(pd, signal[VARIABLE_CHANGED], 0, idx);
+  g_signal_emit (pd, signal[VARIABLE_CHANGED], 0, idx);
 }
 
 static const struct dict_callbacks gui_callbacks =
@@ -200,7 +200,7 @@ static const struct dict_callbacks gui_callbacks =
 static void
 psppire_dict_init (PsppireDict *psppire_dict)
 {
-  psppire_dict->stamp = g_random_int();
+  psppire_dict->stamp = g_random_int ();
 }
 
 /**
@@ -229,8 +229,8 @@ auto_generate_var_name (PsppireDict *dict)
   gint d = 0;
   static gchar name[10];
 
-  while (g_snprintf(name, 10, "VAR%05d",d++),
-        psppire_dict_lookup_var(dict, name))
+  while (g_snprintf (name, 10, "VAR%05d",d++),
+        psppire_dict_lookup_var (dict, name))
     ;
 
   return name;
@@ -240,31 +240,31 @@ auto_generate_var_name (PsppireDict *dict)
    If NAME is null, then a name will be automatically assigned.
  */
 void
-psppire_dict_insert_variable(PsppireDict *d, gint idx, const gchar *name)
+psppire_dict_insert_variable (PsppireDict *d, gint idx, const gchar *name)
 {
   struct variable *var ;
-  g_return_if_fail(d);
-  g_return_if_fail(G_IS_PSPPIRE_DICT(d));
+  g_return_if_fail (d);
+  g_return_if_fail (G_IS_PSPPIRE_DICT(d));
 
 
   if ( ! name )
-    name = auto_generate_var_name(d);
+    name = auto_generate_var_name (d);
 
-  var = dict_create_var(d->dict, name, 0);
+  var = dict_create_var (d->dict, name, 0);
 
-  dict_reorder_var(d->dict, var, idx);
+  dict_reorder_var (d->dict, var, idx);
 
-  g_signal_emit(d, signal[VARIABLE_INSERTED], 0, idx );
+  g_signal_emit (d, signal[VARIABLE_INSERTED], 0, idx );
 }
 
 /* Delete N variables beginning at FIRST */
 void
-psppire_dict_delete_variables(PsppireDict *d, gint first, gint n)
+psppire_dict_delete_variables (PsppireDict *d, gint first, gint n)
 {
   gint idx;
-  g_return_if_fail(d);
-  g_return_if_fail(d->dict);
-  g_return_if_fail(G_IS_PSPPIRE_DICT(d));
+  g_return_if_fail (d);
+  g_return_if_fail (d->dict);
+  g_return_if_fail (G_IS_PSPPIRE_DICT(d));
 
   for (idx = 0 ; idx < n ; ++idx )
     {
@@ -274,35 +274,35 @@ psppire_dict_delete_variables(PsppireDict *d, gint first, gint n)
       if ( first >= dict_get_var_cnt (d->dict))
        break;
 
-      var = dict_get_var(d->dict, first);
+      var = dict_get_var (d->dict, first);
       dict_delete_var (d->dict, var);
     }
-  dict_compact_values(d->dict);
+  dict_compact_values (d->dict);
 
-  g_signal_emit(d, signal[VARIABLES_DELETED], 0, first, idx );
+  g_signal_emit (d, signal[VARIABLES_DELETED], 0, first, idx );
 }
 
 
 void
-psppire_dict_set_name(PsppireDict* d, gint idx, const gchar *name)
+psppire_dict_set_name (PsppireDict* d, gint idx, const gchar *name)
 {
   struct variable *var;
-  g_assert(d);
-  g_assert(G_IS_PSPPIRE_DICT(d));
+  g_assert (d);
+  g_assert (G_IS_PSPPIRE_DICT(d));
 
 
-  if ( idx < dict_get_var_cnt(d->dict))
+  if ( idx < dict_get_var_cnt (d->dict))
     {
       /* This is an existing variable? */
-      var = dict_get_var(d->dict, idx);
-      dict_rename_var(d->dict, var, name);
-      g_signal_emit(d, signal[VARIABLE_CHANGED], 0, idx);
+      var = dict_get_var (d->dict, idx);
+      dict_rename_var (d->dict, var, name);
+      g_signal_emit (d, signal[VARIABLE_CHANGED], 0, idx);
     }
   else
     {
       /* new variable */
-      dict_create_var(d->dict, name, 0);
-      g_signal_emit(d, signal[VARIABLE_INSERTED], 0, idx);
+      dict_create_var (d->dict, name, 0);
+      g_signal_emit (d, signal[VARIABLE_INSERTED], 0, idx);
     }
 }
 
@@ -310,10 +310,10 @@ psppire_dict_set_name(PsppireDict* d, gint idx, const gchar *name)
 
 /* Return the IDXth variable */
 struct variable *
-psppire_dict_get_variable(PsppireDict *d, gint idx)
+psppire_dict_get_variable (PsppireDict *d, gint idx)
 {
-  g_return_val_if_fail(d, NULL);
-  g_return_val_if_fail(d->dict, NULL);
+  g_return_val_if_fail (d, NULL);
+  g_return_val_if_fail (d->dict, NULL);
 
   if ( dict_get_var_cnt (d->dict) <= idx )
     return NULL;
@@ -349,25 +349,25 @@ psppire_dict_lookup_var (const PsppireDict *d, const gchar *name)
 void
 psppire_dict_var_changed (PsppireDict *d, gint idx)
 {
-  g_return_if_fail(d);
+  g_return_if_fail (d);
 
-  g_signal_emit(d, signal[VARIABLE_CHANGED], 0, idx);
+  g_signal_emit (d, signal[VARIABLE_CHANGED], 0, idx);
 }
 
 
 /* Clears the contents of D */
 void
-psppire_dict_clear(PsppireDict *d)
+psppire_dict_clear (PsppireDict *d)
 {
-  g_return_if_fail(d);
-  g_return_if_fail(d->dict);
+  g_return_if_fail (d);
+  g_return_if_fail (d->dict);
 
   {
-    const gint n_vars = dict_get_var_cnt(d->dict);
+    const gint n_vars = dict_get_var_cnt (d->dict);
 
-    dict_clear(d->dict);
+    dict_clear (d->dict);
 
-    g_signal_emit(d, signal[VARIABLES_DELETED], 0, 0, n_vars );
+    g_signal_emit (d, signal[VARIABLES_DELETED], 0, 0, n_vars );
   }
 }
 
@@ -378,16 +378,16 @@ psppire_dict_clear(PsppireDict *d)
    If REPORT is true, then invalid names will be reported as such as errors
 */
 gboolean
-psppire_dict_check_name(const PsppireDict *dict,
+psppire_dict_check_name (const PsppireDict *dict,
                     const gchar *name, gboolean report)
 {
-  if ( ! var_is_valid_name(name, report ) )
+  if ( ! var_is_valid_name (name, report ) )
       return FALSE;
 
-  if (psppire_dict_lookup_var(dict, name))
+  if (psppire_dict_lookup_var (dict, name))
     {
       if ( report )
-       msg(ME,"Duplicate variable name.");
+       msg (ME,"Duplicate variable name.");
       return FALSE;
     }
 
@@ -398,7 +398,7 @@ psppire_dict_check_name(const PsppireDict *dict,
 inline gint
 psppire_dict_get_next_value_idx (const PsppireDict *dict)
 {
-  return dict_get_next_value_idx(dict->dict);
+  return dict_get_next_value_idx (dict->dict);
 }
 
 
@@ -417,7 +417,7 @@ psppire_dict_resize_variable (PsppireDict *d, const struct variable *pv,
 
   fv = var_get_case_index (pv);
 
-  g_signal_emit(d, signal[VARIABLE_RESIZED], 0,
+  g_signal_emit (d, signal[VARIABLE_RESIZED], 0,
                fv + old_size,
                new_size - old_size );
 }
@@ -484,7 +484,7 @@ tree_model_column_type (GtkTreeModel *model, gint index)
 {
   g_return_val_if_fail (G_IS_PSPPIRE_DICT(model), (GType) 0);
 
-  switch(index)
+  switch (index)
     {
     case DICT_TVM_COL_NAME:
       return G_TYPE_STRING;
@@ -493,16 +493,16 @@ tree_model_column_type (GtkTreeModel *model, gint index)
       return G_TYPE_POINTER;
       break;
     default:
-      g_return_val_if_reached((GType)0);
+      g_return_val_if_reached ((GType)0);
       break;
     }
 
-  g_assert_not_reached();
+  g_assert_not_reached ();
   return ((GType)0);
 }
 
 static gboolean
-tree_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *path)
+tree_model_get_iter (GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *path)
 {
   gint *indices, depth;
   gint n;
@@ -515,7 +515,7 @@ tree_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *path)
   indices = gtk_tree_path_get_indices (path);
   depth = gtk_tree_path_get_depth (path);
 
-  g_return_val_if_fail(depth == 1, FALSE);
+  g_return_val_if_fail (depth == 1, FALSE);
 
   n = indices[0];
 
@@ -534,13 +534,13 @@ tree_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *path)
 
 
 static gboolean
-tree_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter)
+tree_model_iter_next (GtkTreeModel *model, GtkTreeIter *iter)
 {
   PsppireDict *dict = PSPPIRE_DICT (model);
   struct variable *variable;
   gint idx;
 
-  g_return_val_if_fail(iter->stamp == dict->stamp, FALSE);
+  g_return_val_if_fail (iter->stamp == dict->stamp, FALSE);
 
   if ( iter == NULL || iter->user_data == NULL)
     return FALSE;
@@ -549,7 +549,7 @@ tree_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter)
 
   idx = var_get_dict_index (variable);
 
-  if ( idx + 1 >= psppire_dict_get_var_cnt(dict))
+  if ( idx + 1 >= psppire_dict_get_var_cnt (dict))
     return FALSE;
 
   variable = psppire_dict_get_variable (dict, idx + 1);
@@ -562,68 +562,68 @@ tree_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter)
 }
 
 static GtkTreePath *
-tree_model_get_path(GtkTreeModel *model, GtkTreeIter *iter)
+tree_model_get_path (GtkTreeModel *model, GtkTreeIter *iter)
 {
   GtkTreePath *path;
   struct variable *variable;
   PsppireDict *dict = PSPPIRE_DICT (model);
 
-  g_return_val_if_fail(iter->stamp == dict->stamp, FALSE);
+  g_return_val_if_fail (iter->stamp == dict->stamp, FALSE);
 
   variable = (struct variable *) iter->user_data;
 
-  path = gtk_tree_path_new();
-  gtk_tree_path_append_index(path, var_get_dict_index (variable));
+  path = gtk_tree_path_new ();
+  gtk_tree_path_append_index (path, var_get_dict_index (variable));
 
   return path;
 }
 
 
 static void
-tree_model_get_value(GtkTreeModel *model, GtkTreeIter *iter,
+tree_model_get_value (GtkTreeModel *model, GtkTreeIter *iter,
                     gint column, GValue *value)
 {
   struct variable *variable;
   PsppireDict *dict = PSPPIRE_DICT (model);
 
-  g_return_if_fail(iter->stamp == dict->stamp);
+  g_return_if_fail (iter->stamp == dict->stamp);
 
   variable = (struct variable *) iter->user_data;
 
-  switch(column)
+  switch (column)
     {
     case DICT_TVM_COL_NAME:
-      g_value_init(value, G_TYPE_STRING);
-      g_value_set_string(value, var_get_name(variable));
+      g_value_init (value, G_TYPE_STRING);
+      g_value_set_string (value, var_get_name (variable));
       break;
     case DICT_TVM_COL_VAR:
-      g_value_init(value, G_TYPE_POINTER);
-      g_value_set_pointer(value, variable);
+      g_value_init (value, G_TYPE_POINTER);
+      g_value_set_pointer (value, variable);
       break;
     default:
-      g_return_if_reached();
+      g_return_if_reached ();
       break;
     }
 }
 
 
 static gboolean
-tree_model_nth_child(GtkTreeModel *model, GtkTreeIter *iter,
+tree_model_nth_child (GtkTreeModel *model, GtkTreeIter *iter,
                     GtkTreeIter *parent, gint n)
 {
   PsppireDict *dict;
-  g_return_val_if_fail(G_IS_PSPPIRE_DICT(model), FALSE);
+  g_return_val_if_fail (G_IS_PSPPIRE_DICT(model), FALSE);
 
   dict = PSPPIRE_DICT(model);
 
   if ( parent )
     return FALSE;
 
-  if ( n >= psppire_dict_get_var_cnt(dict) )
+  if ( n >= psppire_dict_get_var_cnt (dict) )
     return FALSE;
 
   iter->stamp = dict->stamp;
-  iter->user_data = psppire_dict_get_variable(dict, n);
+  iter->user_data = psppire_dict_get_variable (dict, n);
 
   if ( !iter->user_data)
     return FALSE;
index f634b3723daf6a02642cd32347edc4295680be11..60d52cde9d3831c9cf2b8aa7437c1343da61ff1f 100644 (file)
@@ -71,7 +71,7 @@ void           psppire_dict_set_name (PsppireDict* s, gint idx, const gchar *nam
 void           psppire_dict_delete_var (PsppireDict *s, gint idx);
 
 /* Return the number of variables in the dictionary */
-gint psppire_dict_get_var_cnt(const PsppireDict *d);
+gint psppire_dict_get_var_cnt (const PsppireDict *d);
 
 /* Return a variable by name.
    Return NULL if it doesn't exist
@@ -79,27 +79,27 @@ gint psppire_dict_get_var_cnt(const PsppireDict *d);
 struct variable * psppire_dict_lookup_var (const PsppireDict *d, const gchar *name);
 
 /* Tell the dictionary that one of its variable has changed */
-void psppire_dict_var_changed(PsppireDict *d, gint idx);
+void psppire_dict_var_changed (PsppireDict *d, gint idx);
 
 
 /* Clears the contents of D */
-void psppire_dict_clear(PsppireDict *d);
+void psppire_dict_clear (PsppireDict *d);
 
 /* Return the IDXth variable */
 
 struct variable * psppire_dict_get_variable (PsppireDict *d, gint idx);
 
 /* Delete N variables beginning at FIRST */
-void psppire_dict_delete_variables(PsppireDict *d, gint first, gint n);
+void psppire_dict_delete_variables (PsppireDict *d, gint first, gint n);
 
 /* Insert a new variable at posn IDX */
-void psppire_dict_insert_variable(PsppireDict *d, gint idx, const gchar *name);
+void psppire_dict_insert_variable (PsppireDict *d, gint idx, const gchar *name);
 
-void psppire_dict_resize_variable(PsppireDict *,
+void psppire_dict_resize_variable (PsppireDict *,
                                  const struct variable *,
                                  gint, gint );
 
-gboolean psppire_dict_check_name(const PsppireDict *dict,
+gboolean psppire_dict_check_name (const PsppireDict *dict,
                              const gchar *name, gboolean report);
 
 gint psppire_dict_get_next_value_idx (const PsppireDict *dict);
index 2e9ee04bcd67a1694c8ee1537a1d266cbcb100ed..240efb331c66239338fc1e6417561f650f735e45 100644 (file)
@@ -55,8 +55,8 @@ struct _PsppireObjectClass
 
 
 /* -- PsppireObject --- */
-GType          psppire_object_get_type(void);
-PsppireObject*      psppire_object_new(void);
+GType          psppire_object_get_type (void);
+PsppireObject*      psppire_object_new (void);
 
 G_END_DECLS
 
index f591277b40de8aa4e0a72013734a66bd456d3ba7..3baf9c6a896c768d1be0e7bc99e1fd70aab91316 100644 (file)
@@ -51,17 +51,17 @@ static void         psppire_var_store_class_init      (PsppireVarStoreClass *cla
 static void         psppire_var_store_sheet_model_init (GSheetModelIface *iface);
 static void         psppire_var_store_finalize        (GObject           *object);
 
-static gchar *psppire_var_store_get_string(const GSheetModel *sheet_model, gint row, gint column);
+static gchar *psppire_var_store_get_string (const GSheetModel *sheet_model, gint row, gint column);
 
-static gboolean  psppire_var_store_clear(GSheetModel *model,  gint row, gint col);
+static gboolean  psppire_var_store_clear (GSheetModel *model,  gint row, gint col);
 
 
-static gboolean psppire_var_store_set_string(GSheetModel *model,
+static gboolean psppire_var_store_set_string (GSheetModel *model,
                                          const gchar *text, gint row, gint column);
 
-static gint psppire_var_store_get_row_count(const GSheetModel * model);
+static gint psppire_var_store_get_row_count (const GSheetModel * model);
 
-static gchar *text_for_column(const struct variable *pv, gint c, GError **err);
+static gchar *text_for_column (const struct variable *pv, gint c, GError **err);
 
 
 static void psppire_var_store_sheet_row_init (GSheetRowIface *iface);
@@ -135,9 +135,9 @@ psppire_var_store_class_init (PsppireVarStoreClass *class)
 static void
 psppire_var_store_init (PsppireVarStore *var_store)
 {
-  GdkColormap *colormap = gdk_colormap_get_system();
+  GdkColormap *colormap = gdk_colormap_get_system ();
 
-  g_assert(gdk_color_parse("gray", &var_store->disabled));
+  g_assert (gdk_color_parse ("gray", &var_store->disabled));
 
   gdk_colormap_alloc_color (colormap, &var_store->disabled, FALSE, TRUE);
 
@@ -145,7 +145,7 @@ psppire_var_store_init (PsppireVarStore *var_store)
 }
 
 static gboolean
-psppire_var_store_item_editable(PsppireVarStore *var_store, gint row, gint column)
+psppire_var_store_item_editable (PsppireVarStore *var_store, gint row, gint column)
 {
   const struct fmt_spec *write_spec ;
 
@@ -192,19 +192,19 @@ psppire_var_store_get_var (PsppireVarStore *store, gint row)
 }
 
 static gboolean
-psppire_var_store_is_editable(const GSheetModel *model, gint row, gint column)
+psppire_var_store_is_editable (const GSheetModel *model, gint row, gint column)
 {
   PsppireVarStore *store = PSPPIRE_VAR_STORE(model);
-  return psppire_var_store_item_editable(store, row, column);
+  return psppire_var_store_item_editable (store, row, column);
 }
 
 
 static const GdkColor *
-psppire_var_store_get_foreground(const GSheetModel *model, gint row, gint column)
+psppire_var_store_get_foreground (const GSheetModel *model, gint row, gint column)
 {
   PsppireVarStore *store = PSPPIRE_VAR_STORE(model);
 
-  if ( ! psppire_var_store_item_editable(store, row, column) )
+  if ( ! psppire_var_store_item_editable (store, row, column) )
     return &store->disabled;
 
   return NULL;
@@ -212,7 +212,7 @@ psppire_var_store_get_foreground(const GSheetModel *model, gint row, gint column
 
 
 const PangoFontDescription *
-psppire_var_store_get_font_desc(const GSheetModel *model,
+psppire_var_store_get_font_desc (const GSheetModel *model,
                              gint row, gint column)
 {
   PsppireVarStore *store = PSPPIRE_VAR_STORE(model);
@@ -254,13 +254,13 @@ psppire_var_store_new (PsppireDict *dict)
 
   retval = g_object_new (GTK_TYPE_VAR_STORE, NULL);
 
-  psppire_var_store_set_dictionary(retval, dict);
+  psppire_var_store_set_dictionary (retval, dict);
 
   return retval;
 }
 
 static void
-var_change_callback(GtkWidget *w, gint n, gpointer data)
+var_change_callback (GtkWidget *w, gint n, gpointer data)
 {
   GSheetModel *model = G_SHEET_MODEL(data);
   g_sheet_model_range_changed (model,
@@ -269,7 +269,7 @@ var_change_callback(GtkWidget *w, gint n, gpointer data)
 
 
 static void
-var_delete_callback(GtkWidget *w, gint first, gint n, gpointer data)
+var_delete_callback (GtkWidget *w, gint first, gint n, gpointer data)
 {
   GSheetModel *model = G_SHEET_MODEL(data);
 
@@ -279,7 +279,7 @@ var_delete_callback(GtkWidget *w, gint first, gint n, gpointer data)
 
 
 static void
-var_insert_callback(GtkWidget *w, gint row, gpointer data)
+var_insert_callback (GtkWidget *w, gint row, gpointer data)
 {
   GSheetModel *model = G_SHEET_MODEL(data);
 
@@ -297,19 +297,19 @@ var_insert_callback(GtkWidget *w, gint row, gpointer data)
  * destroyed.
  **/
 void
-psppire_var_store_set_dictionary(PsppireVarStore *var_store, PsppireDict *dict)
+psppire_var_store_set_dictionary (PsppireVarStore *var_store, PsppireDict *dict)
 {
-  if ( var_store->dict ) g_object_unref(var_store->dict);
+  if ( var_store->dict ) g_object_unref (var_store->dict);
 
   var_store->dict = dict;
 
-  g_signal_connect(dict, "variable-changed", G_CALLBACK(var_change_callback),
+  g_signal_connect (dict, "variable-changed", G_CALLBACK(var_change_callback),
                   var_store);
 
-  g_signal_connect(dict, "variables-deleted", G_CALLBACK(var_delete_callback),
+  g_signal_connect (dict, "variables-deleted", G_CALLBACK(var_delete_callback),
                   var_store);
 
-  g_signal_connect(dict, "variable-inserted", G_CALLBACK(var_insert_callback),
+  g_signal_connect (dict, "variable-inserted", G_CALLBACK(var_insert_callback),
                   var_store);
 
 
@@ -325,13 +325,13 @@ psppire_var_store_finalize (GObject *object)
 }
 
 static gchar *
-psppire_var_store_get_string(const GSheetModel *model, gint row, gint column)
+psppire_var_store_get_string (const GSheetModel *model, gint row, gint column)
 {
   PsppireVarStore *store = PSPPIRE_VAR_STORE(model);
 
   struct variable *pv;
 
-  if ( row >= psppire_dict_get_var_cnt(store->dict))
+  if ( row >= psppire_dict_get_var_cnt (store->dict))
     return 0;
 
   pv = psppire_dict_get_variable (store->dict, row);
@@ -345,7 +345,7 @@ psppire_var_store_get_string(const GSheetModel *model, gint row, gint column)
    Returns true if anything was updated, false otherwise.
 */
 static gboolean
-psppire_var_store_clear(GSheetModel *model,  gint row, gint col)
+psppire_var_store_clear (GSheetModel *model,  gint row, gint col)
 {
   struct variable *pv ;
 
@@ -375,14 +375,14 @@ psppire_var_store_clear(GSheetModel *model,  gint row, gint col)
    Returns true if anything was updated, false otherwise.
 */
 static gboolean
-psppire_var_store_set_string(GSheetModel *model,
+psppire_var_store_set_string (GSheetModel *model,
                          const gchar *text, gint row, gint col)
 {
   struct variable *pv ;
 
   PsppireVarStore *var_store = PSPPIRE_VAR_STORE(model);
 
-  if ( row >= psppire_dict_get_var_cnt(var_store->dict))
+  if ( row >= psppire_dict_get_var_cnt (var_store->dict))
       return FALSE;
 
   pv = psppire_var_store_get_var (var_store, row);
@@ -398,7 +398,7 @@ psppire_var_store_set_string(GSheetModel *model,
       break;
     case COL_COLUMNS:
       if ( ! text) return FALSE;
-      var_set_display_width (pv, atoi(text));
+      var_set_display_width (pv, atoi (text));
       return TRUE;
       break;
     case COL_WIDTH:
@@ -444,7 +444,7 @@ psppire_var_store_set_string(GSheetModel *model,
       }
       break;
     case COL_LABEL:
-      var_set_label(pv, text);
+      var_set_label (pv, text);
       return TRUE;
       break;
     case COL_TYPE:
@@ -456,7 +456,7 @@ psppire_var_store_set_string(GSheetModel *model,
       return FALSE;
       break;
     default:
-      g_assert_not_reached();
+      g_assert_not_reached ();
       return FALSE;
     }
 
@@ -465,7 +465,7 @@ psppire_var_store_set_string(GSheetModel *model,
 
 
 static  gchar *
-text_for_column(const struct variable *pv, gint c, GError **err)
+text_for_column (const struct variable *pv, gint c, GError **err)
 {
   static gchar none[] = N_("None");
 
@@ -495,16 +495,16 @@ text_for_column(const struct variable *pv, gint c, GError **err)
        switch ( write_spec->type )
          {
          case FMT_F:
-           return g_locale_to_utf8(gettext(type_label[VT_NUMERIC]), -1, 0, 0, err);
+           return g_locale_to_utf8 (gettext (type_label[VT_NUMERIC]), -1, 0, 0, err);
            break;
          case FMT_COMMA:
-           return g_locale_to_utf8(gettext(type_label[VT_COMMA]), -1, 0, 0, err);
+           return g_locale_to_utf8 (gettext (type_label[VT_COMMA]), -1, 0, 0, err);
            break;
          case FMT_DOT:
-           return g_locale_to_utf8(gettext(type_label[VT_DOT]), -1, 0, 0, err);
+           return g_locale_to_utf8 (gettext (type_label[VT_DOT]), -1, 0, 0, err);
            break;
          case FMT_E:
-           return g_locale_to_utf8(gettext(type_label[VT_SCIENTIFIC]), -1, 0, 0, err);
+           return g_locale_to_utf8 (gettext (type_label[VT_SCIENTIFIC]), -1, 0, 0, err);
            break;
          case FMT_DATE:
          case FMT_EDATE:
@@ -519,26 +519,26 @@ text_for_column(const struct variable *pv, gint c, GError **err)
          case FMT_DTIME:
          case FMT_WKDAY:
          case FMT_MONTH:
-           return g_locale_to_utf8(type_label[VT_DATE], -1, 0, 0, err);
+           return g_locale_to_utf8 (type_label[VT_DATE], -1, 0, 0, err);
            break;
          case FMT_DOLLAR:
-           return g_locale_to_utf8(type_label[VT_DOLLAR], -1, 0, 0, err);
+           return g_locale_to_utf8 (type_label[VT_DOLLAR], -1, 0, 0, err);
            break;
          case FMT_CCA:
          case FMT_CCB:
          case FMT_CCC:
          case FMT_CCD:
          case FMT_CCE:
-           return g_locale_to_utf8(gettext(type_label[VT_CUSTOM]), -1, 0, 0, err);
+           return g_locale_to_utf8 (gettext (type_label[VT_CUSTOM]), -1, 0, 0, err);
            break;
          case FMT_A:
-           return g_locale_to_utf8(gettext(type_label[VT_STRING]), -1, 0, 0, err);
+           return g_locale_to_utf8 (gettext (type_label[VT_STRING]), -1, 0, 0, err);
            break;
          default:
             {
               char str[FMT_STRING_LEN_MAX + 1];
-              g_warning("Unknown format: \"%s\"\n",
-                        fmt_to_string(write_spec, str));
+              g_warning ("Unknown format: \"%s\"\n",
+                        fmt_to_string (write_spec, str));
             }
            break;
          }
@@ -547,30 +547,30 @@ text_for_column(const struct variable *pv, gint c, GError **err)
     case COL_WIDTH:
       {
        gchar *s;
-       GString *gstr = g_string_sized_new(10);
-       g_string_printf(gstr, _("%d"), write_spec->w);
-       s = g_locale_to_utf8(gstr->str, gstr->len, 0, 0, err);
-       g_string_free(gstr, TRUE);
+       GString *gstr = g_string_sized_new (10);
+       g_string_printf (gstr, _("%d"), write_spec->w);
+       s = g_locale_to_utf8 (gstr->str, gstr->len, 0, 0, err);
+       g_string_free (gstr, TRUE);
        return s;
       }
       break;
     case COL_DECIMALS:
       {
        gchar *s;
-       GString *gstr = g_string_sized_new(10);
-       g_string_printf(gstr, _("%d"), write_spec->d);
-       s = g_locale_to_utf8(gstr->str, gstr->len, 0, 0, err);
-       g_string_free(gstr, TRUE);
+       GString *gstr = g_string_sized_new (10);
+       g_string_printf (gstr, _("%d"), write_spec->d);
+       s = g_locale_to_utf8 (gstr->str, gstr->len, 0, 0, err);
+       g_string_free (gstr, TRUE);
        return s;
       }
       break;
     case COL_COLUMNS:
       {
        gchar *s;
-       GString *gstr = g_string_sized_new(10);
-       g_string_printf(gstr, _("%d"), var_get_display_width (pv));
-       s = g_locale_to_utf8(gstr->str, gstr->len, 0, 0, err);
-       g_string_free(gstr, TRUE);
+       GString *gstr = g_string_sized_new (10);
+       g_string_printf (gstr, _("%d"), var_get_display_width (pv));
+       s = g_locale_to_utf8 (gstr->str, gstr->len, 0, 0, err);
+       g_string_free (gstr, TRUE);
        return s;
       }
       break;
@@ -582,57 +582,57 @@ text_for_column(const struct variable *pv, gint c, GError **err)
       {
        gchar *s;
        const struct missing_values *miss = var_get_missing_values (pv);
-       if ( mv_is_empty(miss))
-         return g_locale_to_utf8(gettext(none), -1, 0, 0, err);
+       if ( mv_is_empty (miss))
+         return g_locale_to_utf8 (gettext (none), -1, 0, 0, err);
        else
          {
            if ( ! mv_has_range (miss))
              {
-               GString *gstr = g_string_sized_new(10);
-               const int n = mv_n_values(miss);
+               GString *gstr = g_string_sized_new (10);
+               const int n = mv_n_values (miss);
                gchar *mv[4] = {0,0,0,0};
                gint i;
-               for(i = 0 ; i < n; ++i )
+               for (i = 0 ; i < n; ++i )
                  {
                    union value v;
-                   mv_peek_value(miss, &v, i);
-                   mv[i] = value_to_text(v, *write_spec);
+                   mv_peek_value (miss, &v, i);
+                   mv[i] = value_to_text (v, *write_spec);
                    if ( i > 0 )
-                     g_string_append(gstr, ", ");
-                   g_string_append(gstr, mv[i]);
-                   g_free(mv[i]);
+                     g_string_append (gstr, ", ");
+                   g_string_append (gstr, mv[i]);
+                   g_free (mv[i]);
                  }
-               s = pspp_locale_to_utf8(gstr->str, gstr->len, err);
-               g_string_free(gstr, TRUE);
+               s = pspp_locale_to_utf8 (gstr->str, gstr->len, err);
+               g_string_free (gstr, TRUE);
              }
            else
              {
-               GString *gstr = g_string_sized_new(10);
+               GString *gstr = g_string_sized_new (10);
                gchar *l, *h;
                union value low, high;
-               mv_peek_range(miss, &low.f, &high.f);
+               mv_peek_range (miss, &low.f, &high.f);
 
-               l = value_to_text(low, *write_spec);
-               h = value_to_text(high, *write_spec);
+               l = value_to_text (low, *write_spec);
+               h = value_to_text (high, *write_spec);
 
-               g_string_printf(gstr, "%s - %s", l, h);
-               g_free(l);
-               g_free(h);
+               g_string_printf (gstr, "%s - %s", l, h);
+               g_free (l);
+               g_free (h);
 
-               if ( mv_has_value(miss))
+               if ( mv_has_value (miss))
                  {
                    gchar *ss = 0;
                    union value v;
-                   mv_peek_value(miss, &v, 0);
+                   mv_peek_value (miss, &v, 0);
 
-                   ss = value_to_text(v, *write_spec);
+                   ss = value_to_text (v, *write_spec);
 
-                   g_string_append(gstr, ", ");
-                   g_string_append(gstr, ss);
-                   free(ss);
+                   g_string_append (gstr, ", ");
+                   g_string_append (gstr, ss);
+                   free (ss);
                  }
-               s = pspp_locale_to_utf8(gstr->str, gstr->len, err);
-               g_string_free(gstr, TRUE);
+               s = pspp_locale_to_utf8 (gstr->str, gstr->len, err);
+               g_string_free (gstr, TRUE);
              }
 
            return s;
@@ -670,10 +670,10 @@ text_for_column(const struct variable *pv, gint c, GError **err)
       break;
     case COL_ALIGN:
       {
-       const gint align = var_get_alignment(pv);
+       const gint align = var_get_alignment (pv);
 
        g_assert (align < n_ALIGNMENTS);
-       return g_locale_to_utf8(gettext(alignments[align]), -1, 0, 0, err);
+       return g_locale_to_utf8 (gettext (alignments[align]), -1, 0, 0, err);
       }
       break;
     case COL_MEASURE:
@@ -693,14 +693,14 @@ text_for_column(const struct variable *pv, gint c, GError **err)
 
 /* Return the number of variables */
 gint
-psppire_var_store_get_var_cnt(PsppireVarStore  *store)
+psppire_var_store_get_var_cnt (PsppireVarStore  *store)
 {
-  return psppire_dict_get_var_cnt(store->dict);
+  return psppire_dict_get_var_cnt (store->dict);
 }
 
 
 void
-psppire_var_store_set_font(PsppireVarStore *store, const PangoFontDescription *fd)
+psppire_var_store_set_font (PsppireVarStore *store, const PangoFontDescription *fd)
 {
   g_return_if_fail (store);
   g_return_if_fail (PSPPIRE_IS_VAR_STORE (store));
@@ -712,13 +712,13 @@ psppire_var_store_set_font(PsppireVarStore *store, const PangoFontDescription *f
 
 
 static gint
-psppire_var_store_get_row_count(const GSheetModel * model)
+psppire_var_store_get_row_count (const GSheetModel * model)
 {
   gint rows = 0;
   PsppireVarStore *vs = PSPPIRE_VAR_STORE(model);
 
   if (vs->dict)
-    rows =  psppire_dict_get_var_cnt(vs->dict);
+    rows =  psppire_dict_get_var_cnt (vs->dict);
 
   return rows ;
 }
@@ -726,47 +726,47 @@ psppire_var_store_get_row_count(const GSheetModel * model)
 /* Row related funcs */
 
 static gint
-geometry_get_row_count(const GSheetRow *geom, gpointer data)
+geometry_get_row_count (const GSheetRow *geom, gpointer data)
 {
   gint rows = 0;
   PsppireVarStore *vs = PSPPIRE_VAR_STORE(geom);
 
   if (vs->dict)
-    rows =  psppire_dict_get_var_cnt(vs->dict);
+    rows =  psppire_dict_get_var_cnt (vs->dict);
 
   return rows + TRAILING_ROWS;
 }
 
 
 static gint
-geometry_get_height(const GSheetRow *geom, gint row, gpointer data)
+geometry_get_height (const GSheetRow *geom, gint row, gpointer data)
 {
   return 25;
 }
 
 
 static gboolean
-geometry_is_sensitive(const GSheetRow *geom, gint row, gpointer data)
+geometry_is_sensitive (const GSheetRow *geom, gint row, gpointer data)
 {
   PsppireVarStore *vs = PSPPIRE_VAR_STORE(geom);
 
   if ( ! vs->dict)
     return FALSE;
 
-  return  row < psppire_dict_get_var_cnt(vs->dict);
+  return  row < psppire_dict_get_var_cnt (vs->dict);
 }
 
 static
-gboolean always_true()
+gboolean always_true ()
 {
   return TRUE;
 }
 
 
 static gchar *
-geometry_get_button_label(const GSheetRow *geom, gint unit, gpointer data)
+geometry_get_button_label (const GSheetRow *geom, gint unit, gpointer data)
 {
-  gchar *label = g_strdup_printf(_("%d"), unit);
+  gchar *label = g_strdup_printf (_("%d"), unit);
 
   return label;
 }
index b2eaf673253043eafb371283f6c1a105792f106c..d61e25ff44aecbed8be08628531d538f164f7dab 100644 (file)
@@ -83,7 +83,7 @@ void psppire_var_store_set_dictionary (PsppireVarStore *var_store, PsppireDict *
 /* Return the number of variables */
 gint psppire_var_store_get_var_cnt (PsppireVarStore      *var_store);
 
-void psppire_var_store_set_font(PsppireVarStore *store, const PangoFontDescription *fd);
+void psppire_var_store_set_font (PsppireVarStore *store, const PangoFontDescription *fd);
 
 
 #ifdef __cplusplus
index 7caa47c8cc91e5475a3994d8bfb807b835e44c5c..bae77e87b67056ea082bfe4de666d3ff397b90d0 100644 (file)
@@ -58,7 +58,7 @@ static bool parse_command_line (int *argc, char ***argv,
 #define N_(msgid) msgid
 
 static void
-give_help(void)
+give_help (void)
 {
   static struct msg m = {
     MSG_GENERAL,
@@ -68,9 +68,9 @@ give_help(void)
   };
 
   if (! m.text)
-    m.text=g_strdup(_("Sorry. The help system hasn't yet been implemented."));
+    m.text=g_strdup (_("Sorry. The help system hasn't yet been implemented."));
 
-  popup_message(&m);
+  popup_message (&m);
 }
 
 PsppireVarStore *the_var_store = 0;
@@ -82,7 +82,7 @@ struct dataset * the_dataset = NULL;
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   struct casefile_factory *factory;
   PsppireDict *dictionary = 0;
@@ -96,12 +96,12 @@ main(int argc, char *argv[])
   GError *err = 0;
   gchar *vers;
 
-  gtk_init(&argc, &argv);
-  if ( (vers = gtk_check_version(GTK_MAJOR_VERSION,
+  gtk_init (&argc, &argv);
+  if ( (vers = gtk_check_version (GTK_MAJOR_VERSION,
                                 GTK_MINOR_VERSION,
                                 GTK_MICRO_VERSION)) )
     {
-      g_critical(vers);
+      g_critical (vers);
     }
 
 
@@ -113,16 +113,16 @@ main(int argc, char *argv[])
 
   textdomain (PACKAGE);
 
-  if ( ! parse_command_line(&argc, &argv, &filename, &err) )
+  if ( ! parse_command_line (&argc, &argv, &filename, &err) )
     {
-      g_clear_error(&err);
+      g_clear_error (&err);
       return 0;
     }
 
-  glade_init();
+  glade_init ();
 
-  fmt_init();
-  settings_init();
+  fmt_init ();
+  settings_init ();
   fh_init ();
   factory = flexifile_factory_create ();
   the_source_stream = create_source_stream (
@@ -138,42 +138,42 @@ main(int argc, char *argv[])
                                dataset_dict (the_dataset)
                                );
 
-  bind_textdomain_codeset(PACKAGE, "UTF-8");
+  bind_textdomain_codeset (PACKAGE, "UTF-8");
 
   /* Create the model for the var_sheet */
-  the_var_store = psppire_var_store_new(dictionary);
+  the_var_store = psppire_var_store_new (dictionary);
 
 
   the_data_store = psppire_data_store_new (dictionary);
 
-  create_icon_factory();
+  create_icon_factory ();
 
 #if 0
   /* load the interface */
-  data_editor_xml = glade_xml_new(PKGDATADIR "/data-editor.glade", NULL, NULL);
+  data_editor_xml = glade_xml_new (PKGDATADIR "/data-editor.glade", NULL, NULL);
 
   if ( !data_editor_xml ) return 1;
 
-  data_editor = get_widget_assert(data_editor_xml, "data_editor");
+  data_editor = get_widget_assert (data_editor_xml, "data_editor");
 
   /* connect the signals in the interface */
-  glade_xml_signal_autoconnect(data_editor_xml);
+  glade_xml_signal_autoconnect (data_editor_xml);
 
-  var_sheet  = GTK_SHEET(get_widget_assert(data_editor_xml, "variable_sheet"));
-  data_sheet = GTK_SHEET(get_widget_assert(data_editor_xml, "data_sheet"));
+  var_sheet  = GTK_SHEET(get_widget_assert (data_editor_xml, "variable_sheet"));
+  data_sheet = GTK_SHEET(get_widget_assert (data_editor_xml, "data_sheet"));
 
-  gtk_sheet_set_model(var_sheet, G_SHEET_MODEL(the_var_store));
+  gtk_sheet_set_model (var_sheet, G_SHEET_MODEL(the_var_store));
 
-  gtk_sheet_set_model(data_sheet, G_SHEET_MODEL(the_data_store));
+  gtk_sheet_set_model (data_sheet, G_SHEET_MODEL(the_data_store));
 
-  var_data_selection_init();
+  var_data_selection_init ();
 
   {
-  GList *helps = glade_xml_get_widget_prefix(data_editor_xml, "help_button_");
+  GList *helps = glade_xml_get_widget_prefix (data_editor_xml, "help_button_");
 
   GList *i;
-  for ( i = g_list_first(helps); i ; i = g_list_next(i))
-      g_signal_connect(GTK_WIDGET(i->data), "clicked", give_help, 0);
+  for ( i = g_list_first (helps); i ; i = g_list_next (i))
+      g_signal_connect (GTK_WIDGET(i->data), "clicked", give_help, 0);
   }
 
 #endif
@@ -181,19 +181,19 @@ main(int argc, char *argv[])
   new_data_window (NULL, NULL);
 
   /* start the event loop */
-  gtk_main();
+  gtk_main ();
 
   destroy_source_stream (the_source_stream);
-  message_dialog_done();
+  message_dialog_done ();
 
-  settings_done();
+  settings_done ();
 
   return 0;
 }
 
 
 /* Parses the command line specified by ARGC and ARGV as received by
-   main().  Returns true if normal execution should proceed,
+   main ().  Returns true if normal execution should proceed,
    false if the command-line indicates that PSPP should exit. */
 static bool
 parse_command_line (int *argc, char ***argv, gchar **filename, GError **err)
@@ -241,7 +241,7 @@ parse_command_line (int *argc, char ***argv, gchar **filename, GError **err)
 void
 create_icon_factory (void)
 {
-  GtkIconFactory *factory = gtk_icon_factory_new();
+  GtkIconFactory *factory = gtk_icon_factory_new ();
 
   GtkIconSet *icon_set;
 
index cdf0340844fa3b2c015f19dbc3c179d8c18945d4..f233dc48e36f733f369811686c426f107c857836 100644 (file)
@@ -68,15 +68,15 @@ dictionary_selection_changed (GtkTreeSelection *selection,
   GtkTreeSelection *otherselection ;
   struct sort_cases_dialog *dialog = (struct sort_cases_dialog*) data;
 
-  if ( 0 == gtk_tree_selection_count_selected_rows(selection) )
+  if ( 0 == gtk_tree_selection_count_selected_rows (selection) )
     return ;
 
-  gtk_arrow_set(dialog->arrow, GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
+  gtk_arrow_set (dialog->arrow, GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
   dialog->button_state = VAR_SELECT;
 
-  otherselection = gtk_tree_view_get_selection(dialog->criteria_view);
+  otherselection = gtk_tree_view_get_selection (dialog->criteria_view);
 
-  gtk_tree_selection_unselect_all(otherselection);
+  gtk_tree_selection_unselect_all (otherselection);
 }
 
 
@@ -88,29 +88,29 @@ criteria_selection_changed (GtkTreeSelection *selection,
   GtkTreeSelection *otherselection ;
   struct sort_cases_dialog *dialog = (struct sort_cases_dialog*) data;
 
-  if ( 0 == gtk_tree_selection_count_selected_rows(selection) )
+  if ( 0 == gtk_tree_selection_count_selected_rows (selection) )
     return ;
 
-  otherselection = gtk_tree_view_get_selection(dialog->dict_view);
+  otherselection = gtk_tree_view_get_selection (dialog->dict_view);
 
-  gtk_arrow_set(dialog->arrow, GTK_ARROW_LEFT, GTK_SHADOW_OUT);
+  gtk_arrow_set (dialog->arrow, GTK_ARROW_LEFT, GTK_SHADOW_OUT);
   dialog->button_state = VAR_DESELECT;
 
-  gtk_tree_selection_unselect_all(otherselection);
+  gtk_tree_selection_unselect_all (otherselection);
 }
 
 
 /* Occurs when the dialog box is deleted (eg: closed via the title bar) */
 static gint
-delete_event_callback(GtkWidget *widget,
+delete_event_callback (GtkWidget *widget,
                      GdkEvent  *event,
                      gpointer   data)
 {
   struct sort_cases_dialog *dialog = (struct sort_cases_dialog*) data;
 
-  g_main_loop_quit(dialog->loop);
+  g_main_loop_quit (dialog->loop);
 
-  gtk_widget_hide_on_delete(widget);
+  gtk_widget_hide_on_delete (widget);
 
   dialog->response = GTK_RESPONSE_DELETE_EVENT;
 
@@ -119,34 +119,34 @@ delete_event_callback(GtkWidget *widget,
 
 /* Occurs when the cancel button is clicked */
 static void
-sort_cases_cancel_callback(GObject *obj, gpointer data)
+sort_cases_cancel_callback (GObject *obj, gpointer data)
 {
   struct sort_cases_dialog *dialog = (struct sort_cases_dialog*) data;
 
-  gtk_widget_hide(dialog->window);
+  gtk_widget_hide (dialog->window);
 
-  g_main_loop_quit(dialog->loop);
+  g_main_loop_quit (dialog->loop);
 
   dialog->response = GTK_RESPONSE_CANCEL;
 }
 
 /* Occurs when the reset button is clicked */
 static void
-sort_cases_reset_callback(GObject *obj, gpointer data)
+sort_cases_reset_callback (GObject *obj, gpointer data)
 {
   struct sort_cases_dialog *dialog = (struct sort_cases_dialog*) data;
 
-  gtk_arrow_set(dialog->arrow, GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
+  gtk_arrow_set (dialog->arrow, GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
   dialog->button_state = VAR_SELECT;
 
-  gtk_list_store_clear(dialog->criteria_list);
+  gtk_list_store_clear (dialog->criteria_list);
 }
 
 
 /* Add variables currently selected in the dictionary tree view to the
    list of criteria */
 static void
-select_criteria(GtkTreeModel *model, GtkTreePath *path,
+select_criteria (GtkTreeModel *model, GtkTreePath *path,
                GtkTreeIter *iter, gpointer data)
 {
   GtkTreeIter new_iter;
@@ -166,29 +166,29 @@ select_criteria(GtkTreeModel *model, GtkTreePath *path,
     SRT_ASCEND:SRT_DESCEND;
 
   /* Append to the list of criteria */
-  gtk_list_store_append(dialog->criteria_list, &new_iter);
-  gtk_list_store_set(dialog->criteria_list,
+  gtk_list_store_append (dialog->criteria_list, &new_iter);
+  gtk_list_store_set (dialog->criteria_list,
                     &new_iter, CRIT_TVM_IDX, index, -1);
-  gtk_list_store_set(dialog->criteria_list,
+  gtk_list_store_set (dialog->criteria_list,
                     &new_iter, CRIT_TVM_DIR, dir, -1);
 }
 
 /* Create a list of the RowRefs which are to be removed from the
    criteria list */
 static void
-path_to_row_ref(GtkTreeModel *model, GtkTreePath *path,
+path_to_row_ref (GtkTreeModel *model, GtkTreePath *path,
                GtkTreeIter *iter, gpointer data)
 {
   GList **rrlist = data;
-  GtkTreeRowReference *rowref = gtk_tree_row_reference_new(model, path);
+  GtkTreeRowReference *rowref = gtk_tree_row_reference_new (model, path);
 
-  *rrlist = g_list_append(*rrlist, rowref);
+  *rrlist = g_list_append (*rrlist, rowref);
 }
 
 
 /* Remove a row from the list of criteria */
 static void
-deselect_criteria(gpointer data,
+deselect_criteria (gpointer data,
                  gpointer user_data)
 {
   GtkTreeIter iter;
@@ -196,13 +196,13 @@ deselect_criteria(gpointer data,
   GtkTreePath *path;
   struct sort_cases_dialog *dialog = (struct sort_cases_dialog*) user_data;
 
-  path = gtk_tree_row_reference_get_path(row_ref);
+  path = gtk_tree_row_reference_get_path (row_ref);
 
-  gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->criteria_list), &iter, path);
+  gtk_tree_model_get_iter (GTK_TREE_MODEL(dialog->criteria_list), &iter, path);
 
-  gtk_list_store_remove(dialog->criteria_list, &iter);
+  gtk_list_store_remove (dialog->criteria_list, &iter);
 
-  gtk_tree_row_reference_free(row_ref);
+  gtk_tree_row_reference_free (row_ref);
 }
 
 
@@ -210,43 +210,43 @@ deselect_criteria(gpointer data,
 /* Callback which occurs when the button to remove variables from the list
    of criteria is clicked. */
 static void
-sort_cases_button_callback(GObject *obj, gpointer data)
+sort_cases_button_callback (GObject *obj, gpointer data)
 {
   struct sort_cases_dialog *dialog = (struct sort_cases_dialog*) data;
 
   if ( dialog->button_state == VAR_SELECT) /* Right facing arrow */
     {
       GtkTreeSelection *selection =
-       gtk_tree_view_get_selection(dialog->dict_view);
+       gtk_tree_view_get_selection (dialog->dict_view);
 
-      gtk_tree_selection_selected_foreach(selection, select_criteria, dialog);
+      gtk_tree_selection_selected_foreach (selection, select_criteria, dialog);
     }
   else   /* Left facing arrow */
     {
       GList *selectedRows = NULL;
       GtkTreeSelection *selection =
-       gtk_tree_view_get_selection(dialog->criteria_view);
+       gtk_tree_view_get_selection (dialog->criteria_view);
 
       /* Make a list of rows to be deleted */
-      gtk_tree_selection_selected_foreach(selection, path_to_row_ref,
+      gtk_tree_selection_selected_foreach (selection, path_to_row_ref,
                                          &selectedRows);
 
       /* ... and delete them */
-      g_list_foreach(selectedRows, deselect_criteria, dialog);
+      g_list_foreach (selectedRows, deselect_criteria, dialog);
 
-      g_list_free(selectedRows);
+      g_list_free (selectedRows);
     }
 }
 
 
 /* Callback which occurs when the OK button is clicked */
 static void
-sort_cases_ok_callback(GObject *obj, gpointer data)
+sort_cases_ok_callback (GObject *obj, gpointer data)
 {
   struct sort_cases_dialog *dialog = (struct sort_cases_dialog*) data;
 
-  gtk_widget_hide(dialog->window);
-  g_main_loop_quit(dialog->loop);
+  gtk_widget_hide (dialog->window);
+  g_main_loop_quit (dialog->loop);
 
   dialog->response = GTK_RESPONSE_OK;
 }
@@ -255,7 +255,7 @@ sort_cases_ok_callback(GObject *obj, gpointer data)
 /* This function is responsible for rendering a criterion in the
    criteria list */
 static void
-criteria_render_func(GtkTreeViewColumn *column, GtkCellRenderer *renderer,
+criteria_render_func (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
                     GtkTreeModel *model, GtkTreeIter *iter,
                     gpointer data)
 {
@@ -266,64 +266,64 @@ criteria_render_func(GtkTreeViewColumn *column, GtkCellRenderer *renderer,
   gchar *varname;
   PsppireDict *dict  = data;
 
-  gtk_tree_model_get(model, iter,
+  gtk_tree_model_get (model, iter,
                     CRIT_TVM_IDX, &var_index,
                     CRIT_TVM_DIR, &direction, -1);
 
-  variable = psppire_dict_get_variable(dict, var_index);
+  variable = psppire_dict_get_variable (dict, var_index);
 
-  varname = pspp_locale_to_utf8 (var_get_name(variable),
+  varname = pspp_locale_to_utf8 (var_get_name (variable),
                                -1, 0);
 
   if ( direction == SRT_ASCEND)
-      buf = g_strdup_printf("%s: %s", varname, _("Ascending"));
+      buf = g_strdup_printf ("%s: %s", varname, _("Ascending"));
   else
-      buf = g_strdup_printf("%s: %s", varname, _("Descending"));
+      buf = g_strdup_printf ("%s: %s", varname, _("Descending"));
 
-  g_free(varname);
+  g_free (varname);
 
-  g_object_set(renderer, "text", buf, NULL);
+  g_object_set (renderer, "text", buf, NULL);
 
-  g_free(buf);
+  g_free (buf);
 }
 
 
 /* Create the dialog */
 struct sort_cases_dialog *
-sort_cases_dialog_create(GladeXML *xml)
+sort_cases_dialog_create (GladeXML *xml)
 {
-  struct sort_cases_dialog *dialog = g_malloc(sizeof(*dialog));
+  struct sort_cases_dialog *dialog = g_malloc (sizeof (*dialog));
 
-  dialog->loop = g_main_loop_new(NULL, FALSE);
+  dialog->loop = g_main_loop_new (NULL, FALSE);
 
-  dialog->window = get_widget_assert(xml, "sort-cases-dialog");
+  dialog->window = get_widget_assert (xml, "sort-cases-dialog");
 
   dialog->dict_view = GTK_TREE_VIEW(get_widget_assert
                                    (xml, "sort-cases-treeview-dict"));
   dialog->criteria_view = GTK_TREE_VIEW(get_widget_assert
                                  (xml, "sort-cases-treeview-criteria"));
 
-  dialog->arrow = GTK_ARROW(get_widget_assert(xml, "sort-cases-arrow"));
-  dialog->button = GTK_BUTTON(get_widget_assert(xml, "sort-cases-button"));
+  dialog->arrow = GTK_ARROW(get_widget_assert (xml, "sort-cases-arrow"));
+  dialog->button = GTK_BUTTON(get_widget_assert (xml, "sort-cases-button"));
 
   dialog->ascending_button =
-    GTK_TOGGLE_BUTTON(get_widget_assert(xml, "sort-cases-button-ascending"));
+    GTK_TOGGLE_BUTTON(get_widget_assert (xml, "sort-cases-button-ascending"));
 
-  g_signal_connect(dialog->window, "delete-event",
+  g_signal_connect (dialog->window, "delete-event",
                   G_CALLBACK(delete_event_callback), dialog);
 
-  g_signal_connect(get_widget_assert(xml, "sort-cases-cancel"),
+  g_signal_connect (get_widget_assert (xml, "sort-cases-cancel"),
                   "clicked", G_CALLBACK(sort_cases_cancel_callback), dialog);
 
-  g_signal_connect(get_widget_assert(xml, "sort-cases-ok"),
+  g_signal_connect (get_widget_assert (xml, "sort-cases-ok"),
                   "clicked", G_CALLBACK(sort_cases_ok_callback), dialog);
 
 
-  g_signal_connect(get_widget_assert(xml, "sort-cases-reset"),
+  g_signal_connect (get_widget_assert (xml, "sort-cases-reset"),
                   "clicked", G_CALLBACK(sort_cases_reset_callback), dialog);
 
 
-  g_signal_connect(get_widget_assert(xml, "sort-cases-button"),
+  g_signal_connect (get_widget_assert (xml, "sort-cases-button"),
                   "clicked", G_CALLBACK(sort_cases_button_callback), dialog);
 
 
@@ -332,39 +332,39 @@ sort_cases_dialog_create(GladeXML *xml)
     GtkTreeViewColumn *col;
 
     GtkTreeSelection *selection =
-      gtk_tree_view_get_selection(dialog->dict_view);
+      gtk_tree_view_get_selection (dialog->dict_view);
 
-    GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
+    GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
 
-    col = gtk_tree_view_column_new_with_attributes(_("Var"),
+    col = gtk_tree_view_column_new_with_attributes (_("Var"),
                                                   renderer,
                                                   "text",
                                                   0,
                                                   NULL);
 
     /* FIXME: make this a value in terms of character widths */
-    g_object_set(col, "min-width",  100, NULL);
+    g_object_set (col, "min-width",  100, NULL);
 
     gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
 
-    gtk_tree_view_append_column(dialog->dict_view, col);
+    gtk_tree_view_append_column (dialog->dict_view, col);
 
-    gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
+    gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
 
-    g_signal_connect(selection, "changed",
+    g_signal_connect (selection, "changed",
                     G_CALLBACK(dictionary_selection_changed), dialog);
   }
 
   {
     /* Set up the variable list treeview */
     GtkTreeSelection *selection =
-      gtk_tree_view_get_selection(dialog->criteria_view);
+      gtk_tree_view_get_selection (dialog->criteria_view);
 
-    gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
+    gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
 
-    dialog->crit_renderer = gtk_cell_renderer_text_new();
+    dialog->crit_renderer = gtk_cell_renderer_text_new ();
 
-    dialog->crit_col = gtk_tree_view_column_new_with_attributes(_("Criteria"),
+    dialog->crit_col = gtk_tree_view_column_new_with_attributes (_("Criteria"),
                                                   dialog->crit_renderer,
                                                   "text",
                                                   0,
@@ -372,21 +372,21 @@ sort_cases_dialog_create(GladeXML *xml)
 
     gtk_tree_view_column_set_sizing (dialog->crit_col, GTK_TREE_VIEW_COLUMN_FIXED);
 
-    gtk_tree_view_append_column(GTK_TREE_VIEW(dialog->criteria_view),
+    gtk_tree_view_append_column (GTK_TREE_VIEW(dialog->criteria_view),
                                dialog->crit_col);
 
-    g_signal_connect(selection, "changed",
+    g_signal_connect (selection, "changed",
                     G_CALLBACK(criteria_selection_changed), dialog);
   }
 
   {
     /* Create the list of criteria */
-    dialog->criteria_list = gtk_list_store_new(2,
+    dialog->criteria_list = gtk_list_store_new (2,
                            G_TYPE_INT, /* index of the variable */
                            G_TYPE_INT  /* Ascending/Descending */
                            );
 
-    gtk_tree_view_set_model(dialog->criteria_view,
+    gtk_tree_view_set_model (dialog->criteria_view,
                            GTK_TREE_MODEL(dialog->criteria_list));
   }
 
@@ -397,7 +397,7 @@ sort_cases_dialog_create(GladeXML *xml)
 
 
 static void
-convert_list_store_to_criteria(GtkListStore *list,
+convert_list_store_to_criteria (GtkListStore *list,
                               PsppireDict *dict,
                               struct sort_criteria *criteria);
 
@@ -407,32 +407,32 @@ convert_list_store_to_criteria(GtkListStore *list,
    with a valid sort criteria which can be used to sort the data.
    This structure and its contents must be freed by the caller. */
 gint
-sort_cases_dialog_run(struct sort_cases_dialog *dialog,
+sort_cases_dialog_run (struct sort_cases_dialog *dialog,
                      PsppireDict *dict,
                      struct sort_criteria *criteria
                      )
 {
-  g_assert(! g_main_loop_is_running(dialog->loop));
+  g_assert (! g_main_loop_is_running (dialog->loop));
 
-  gtk_tree_view_set_model(GTK_TREE_VIEW(dialog->dict_view),
+  gtk_tree_view_set_model (GTK_TREE_VIEW(dialog->dict_view),
                          GTK_TREE_MODEL(dict));
 
 
-  gtk_tree_view_column_set_cell_data_func(dialog->crit_col,
+  gtk_tree_view_column_set_cell_data_func (dialog->crit_col,
                                          dialog->crit_renderer,
                                          criteria_render_func, dict, 0);
 
-  gtk_list_store_clear(dialog->criteria_list);
+  gtk_list_store_clear (dialog->criteria_list);
 
-  gtk_arrow_set(dialog->arrow, GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
+  gtk_arrow_set (dialog->arrow, GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
   dialog->button_state = VAR_SELECT;
 
-  gtk_widget_show(dialog->window);
+  gtk_widget_show (dialog->window);
 
-  g_main_loop_run(dialog->loop);
+  g_main_loop_run (dialog->loop);
 
   if ( GTK_RESPONSE_OK == dialog->response)
-    convert_list_store_to_criteria(dialog->criteria_list,
+    convert_list_store_to_criteria (dialog->criteria_list,
                                   dict, criteria);
 
   return dialog->response;
@@ -442,7 +442,7 @@ sort_cases_dialog_run(struct sort_cases_dialog *dialog,
 
 /* Convert the GtkListStore to a struct sort_criteria*/
 static void
-convert_list_store_to_criteria(GtkListStore *list,
+convert_list_store_to_criteria (GtkListStore *list,
                               PsppireDict *dict,
                               struct sort_criteria *criteria)
 {
@@ -454,12 +454,12 @@ convert_list_store_to_criteria(GtkListStore *list,
 
   criteria->crit_cnt = gtk_tree_model_iter_n_children (model, NULL);
 
-  criteria->crits = g_malloc(sizeof(struct sort_criterion) *
+  criteria->crits = g_malloc (sizeof (struct sort_criterion) *
                             criteria->crit_cnt);
 
-  for(valid = gtk_tree_model_get_iter_first(model, &iter);
+  for (valid = gtk_tree_model_get_iter_first (model, &iter);
       valid;
-      valid = gtk_tree_model_iter_next(model, &iter))
+      valid = gtk_tree_model_iter_next (model, &iter))
     {
       struct variable *variable;
       gint index;
@@ -467,15 +467,15 @@ convert_list_store_to_criteria(GtkListStore *list,
       g_assert ( n < criteria->crit_cnt);
       n++;
 
-      gtk_tree_model_get(model, &iter,
+      gtk_tree_model_get (model, &iter,
                         CRIT_TVM_IDX, &index,
                         CRIT_TVM_DIR, &scn->dir,
                         -1);
 
-      variable = psppire_dict_get_variable(dict, index);
+      variable = psppire_dict_get_variable (dict, index);
 
       scn->fv    = var_get_case_index (variable);
-      scn->width = var_get_width(variable);
+      scn->width = var_get_width (variable);
     }
 }
 
index 216bb2184c28177984b143db0faf05c95bb5ac8f..88d1a21fcc4a3b1cd0fba190022362d4dcc6d91e 100644 (file)
@@ -54,10 +54,10 @@ struct sort_cases_dialog
   gint response;
 };
 
-struct sort_cases_dialog * sort_cases_dialog_create(GladeXML *xml);
+struct sort_cases_dialog * sort_cases_dialog_create (GladeXML *xml);
 
 
-gint sort_cases_dialog_run(struct sort_cases_dialog *dialog,
+gint sort_cases_dialog_run (struct sort_cases_dialog *dialog,
                           PsppireDict *dict,
                           struct sort_criteria *criteria
                           );
index be5580f0d80f40a09a26238851283adf06b4e26c..c28bb6947158916fb1ba58c7b6a36bdd94bb94e0 100644 (file)
@@ -64,9 +64,9 @@ struct val_labs_dialog
 
 
 
-struct val_labs_dialog * val_labs_dialog_create(GladeXML *xml);
+struct val_labs_dialog * val_labs_dialog_create (GladeXML *xml);
 
-void val_labs_dialog_show(struct val_labs_dialog *dialog);
+void val_labs_dialog_show (struct val_labs_dialog *dialog);
 
 
 #endif
index 45111621dade6832b235cc58746fc1970d1a6502..331f343b59e01769385602ad5ebc215204b4fb9c 100644 (file)
@@ -93,7 +93,7 @@ const gchar *const measures[n_MEASURES + 1]={
 };
 
 static GtkListStore *
-create_label_list(const gchar **labels)
+create_label_list (const gchar **labels)
 {
   const gchar *s;
   gint i = 0;
@@ -107,7 +107,7 @@ create_label_list(const gchar **labels)
     {
       gtk_list_store_append (list_store, &iter);
       gtk_list_store_set (list_store, &iter,
-                         0, gettext(s),
+                         0, gettext (s),
                          -1);
     }
 
@@ -117,11 +117,11 @@ create_label_list(const gchar **labels)
 /* Callback for when the alignment combo box
    item is selected */
 static void
-change_alignment(GtkComboBox *cb,
+change_alignment (GtkComboBox *cb,
     gpointer user_data)
 {
   struct variable *pv = user_data;
-  gint active_item = gtk_combo_box_get_active(cb);
+  gint active_item = gtk_combo_box_get_active (cb);
 
   if ( active_item < 0 ) return ;
 
@@ -133,11 +133,11 @@ change_alignment(GtkComboBox *cb,
 /* Callback for when the measure combo box
    item is selected */
 static void
-change_measure(GtkComboBox *cb,
+change_measure (GtkComboBox *cb,
     gpointer user_data)
 {
   struct variable *pv = user_data;
-  gint active_item = gtk_combo_box_get_active(cb);
+  gint active_item = gtk_combo_box_get_active (cb);
 
   if ( active_item < 0 ) return ;
 
@@ -152,20 +152,20 @@ traverse_cell_callback (GtkSheet * sheet,
                        gint *new_row, gint *new_column
                        )
 {
-  PsppireVarStore *var_store = PSPPIRE_VAR_STORE(gtk_sheet_get_model(sheet));
+  PsppireVarStore *var_store = PSPPIRE_VAR_STORE(gtk_sheet_get_model (sheet));
 
-  gint n_vars = psppire_var_store_get_var_cnt(var_store);
+  gint n_vars = psppire_var_store_get_var_cnt (var_store);
 
   if ( row == n_vars && *new_row >= n_vars)
     {
-      GtkEntry *entry = GTK_ENTRY(gtk_sheet_get_entry(sheet));
+      GtkEntry *entry = GTK_ENTRY(gtk_sheet_get_entry (sheet));
 
-      const gchar *name = gtk_entry_get_text(entry);
+      const gchar *name = gtk_entry_get_text (entry);
 
-      if (! psppire_dict_check_name(var_store->dict, name, TRUE))
+      if (! psppire_dict_check_name (var_store->dict, name, TRUE))
        return FALSE;
 
-      psppire_dict_insert_variable(var_store->dict, row, name);
+      psppire_dict_insert_variable (var_store->dict, row, name);
 
       return TRUE;
     }
@@ -178,7 +178,7 @@ traverse_cell_callback (GtkSheet * sheet,
     {
       gint i;
       for ( i = n_vars ; i <= *new_row; ++i )
-       psppire_dict_insert_variable(var_store->dict, i, NULL);
+       psppire_dict_insert_variable (var_store->dict, i, NULL);
     }
 
   return TRUE;
@@ -194,7 +194,7 @@ static gboolean
 var_sheet_cell_entry_leave (GtkSheet * sheet, gint row, gint column,
                            gpointer data)
 {
-  gtk_sheet_change_entry(sheet, GTK_TYPE_ENTRY);
+  gtk_sheet_change_entry (sheet, GTK_TYPE_ENTRY);
   return TRUE;
 }
 
@@ -213,18 +213,18 @@ var_sheet_cell_entry_enter (GtkSheet * sheet, gint row, gint column,
 
   GladeXML *xml;
 
-  g_return_val_if_fail(sheet != NULL, FALSE);
+  g_return_val_if_fail (sheet != NULL, FALSE);
 
-  var_store = PSPPIRE_VAR_STORE (gtk_sheet_get_model(sheet));
+  var_store = PSPPIRE_VAR_STORE (gtk_sheet_get_model (sheet));
 
   g_assert (var_store);
 
-  if ( row >= psppire_var_store_get_var_cnt(var_store))
+  if ( row >= psppire_var_store_get_var_cnt (var_store))
     return TRUE;
 
   xml = glade_xml_new (PKGDATADIR "/data-editor.glade", NULL, NULL);
 
-  gtk_sheet_get_attributes(sheet, row, column, &attributes);
+  gtk_sheet_get_attributes (sheet, row, column, &attributes);
 
   pv = psppire_var_store_get_var (var_store, row);
 
@@ -234,20 +234,20 @@ var_sheet_cell_entry_enter (GtkSheet * sheet, gint row, gint column,
       {
        static GtkListStore *list_store = 0;
        GtkComboBoxEntry *cbe;
-       gtk_sheet_change_entry(sheet, GTK_TYPE_COMBO_BOX_ENTRY);
+       gtk_sheet_change_entry (sheet, GTK_TYPE_COMBO_BOX_ENTRY);
        cbe =
-         GTK_COMBO_BOX_ENTRY(gtk_sheet_get_entry(sheet)->parent);
+         GTK_COMBO_BOX_ENTRY(gtk_sheet_get_entry (sheet)->parent);
 
 
-       if ( ! list_store) list_store = create_label_list(alignments);
+       if ( ! list_store) list_store = create_label_list (alignments);
 
-       gtk_combo_box_set_model(GTK_COMBO_BOX(cbe),
+       gtk_combo_box_set_model (GTK_COMBO_BOX(cbe),
                                GTK_TREE_MODEL(list_store));
 
        gtk_combo_box_entry_set_text_column (cbe, 0);
 
 
-       g_signal_connect(G_OBJECT(cbe),"changed",
+       g_signal_connect (G_OBJECT(cbe),"changed",
                         G_CALLBACK(change_alignment), pv);
       }
       break;
@@ -255,14 +255,14 @@ var_sheet_cell_entry_enter (GtkSheet * sheet, gint row, gint column,
       {
        static GtkListStore *list_store = 0;
        GtkComboBoxEntry *cbe;
-       gtk_sheet_change_entry(sheet, GTK_TYPE_COMBO_BOX_ENTRY);
+       gtk_sheet_change_entry (sheet, GTK_TYPE_COMBO_BOX_ENTRY);
        cbe =
-         GTK_COMBO_BOX_ENTRY(gtk_sheet_get_entry(sheet)->parent);
+         GTK_COMBO_BOX_ENTRY(gtk_sheet_get_entry (sheet)->parent);
 
 
        if ( ! list_store) list_store = create_label_list (measures);
 
-       gtk_combo_box_set_model(GTK_COMBO_BOX(cbe),
+       gtk_combo_box_set_model (GTK_COMBO_BOX(cbe),
                                GTK_TREE_MODEL(list_store));
 
        gtk_combo_box_entry_set_text_column (cbe, 0);
@@ -278,18 +278,18 @@ var_sheet_cell_entry_enter (GtkSheet * sheet, gint row, gint column,
 
        PsppireCustomEntry *customEntry;
 
-       gtk_sheet_change_entry(sheet, PSPPIRE_CUSTOM_ENTRY_TYPE);
+       gtk_sheet_change_entry (sheet, PSPPIRE_CUSTOM_ENTRY_TYPE);
 
        customEntry =
-         PSPPIRE_CUSTOM_ENTRY(gtk_sheet_get_entry(sheet));
+         PSPPIRE_CUSTOM_ENTRY(gtk_sheet_get_entry (sheet));
 
 
        if (!val_labs_dialog )
-           val_labs_dialog = val_labs_dialog_create(xml);
+           val_labs_dialog = val_labs_dialog_create (xml);
 
        val_labs_dialog->pv = pv;
 
-       g_signal_connect_swapped(GTK_OBJECT(customEntry),
+       g_signal_connect_swapped (GTK_OBJECT(customEntry),
                                 "clicked",
                                 GTK_SIGNAL_FUNC(val_labs_dialog_show),
                                 val_labs_dialog);
@@ -300,17 +300,17 @@ var_sheet_cell_entry_enter (GtkSheet * sheet, gint row, gint column,
        static struct missing_val_dialog *missing_val_dialog = 0;
        PsppireCustomEntry *customEntry;
 
-       gtk_sheet_change_entry(sheet, PSPPIRE_CUSTOM_ENTRY_TYPE);
+       gtk_sheet_change_entry (sheet, PSPPIRE_CUSTOM_ENTRY_TYPE);
 
        customEntry =
-         PSPPIRE_CUSTOM_ENTRY(gtk_sheet_get_entry(sheet));
+         PSPPIRE_CUSTOM_ENTRY(gtk_sheet_get_entry (sheet));
 
        if (!missing_val_dialog )
-           missing_val_dialog = missing_val_dialog_create(xml);
+           missing_val_dialog = missing_val_dialog_create (xml);
 
        missing_val_dialog->pv = psppire_var_store_get_var (var_store, row);
 
-       g_signal_connect_swapped(GTK_OBJECT(customEntry),
+       g_signal_connect_swapped (GTK_OBJECT(customEntry),
                                 "clicked",
                                 GTK_SIGNAL_FUNC(missing_val_dialog_show),
                                 missing_val_dialog);
@@ -323,20 +323,20 @@ var_sheet_cell_entry_enter (GtkSheet * sheet, gint row, gint column,
 
        PsppireCustomEntry *customEntry;
 
-       gtk_sheet_change_entry(sheet, PSPPIRE_CUSTOM_ENTRY_TYPE);
+       gtk_sheet_change_entry (sheet, PSPPIRE_CUSTOM_ENTRY_TYPE);
 
        customEntry =
-         PSPPIRE_CUSTOM_ENTRY(gtk_sheet_get_entry(sheet));
+         PSPPIRE_CUSTOM_ENTRY(gtk_sheet_get_entry (sheet));
 
 
        /* Popup the Variable Type dialog box */
        if (!var_type_dialog )
-           var_type_dialog = var_type_dialog_create(xml);
+           var_type_dialog = var_type_dialog_create (xml);
 
 
        var_type_dialog->pv = pv;
 
-       g_signal_connect_swapped(GTK_OBJECT(customEntry),
+       g_signal_connect_swapped (GTK_OBJECT(customEntry),
                                 "clicked",
                                 GTK_SIGNAL_FUNC(var_type_dialog_show),
                                 var_type_dialog);
@@ -350,12 +350,12 @@ var_sheet_cell_entry_enter (GtkSheet * sheet, gint row, gint column,
          {
            gint r_min, r_max;
 
-           const gchar *s = gtk_sheet_cell_get_text(sheet, row, column);
+           const gchar *s = gtk_sheet_cell_get_text (sheet, row, column);
 
            if (s)
              {
                GtkSpinButton *spinButton ;
-               const gint current_value  = atoi(s);
+               const gint current_value  = atoi (s);
                GtkObject *adj ;
 
                const struct fmt_spec *fmt = var_get_write_format (pv);
@@ -374,28 +374,28 @@ var_sheet_cell_entry_enter (GtkSheet * sheet, gint row, gint column,
                    r_max = 255 ; /* Is this a sensible value ? */
                    break;
                  default:
-                   g_assert_not_reached();
+                   g_assert_not_reached ();
                  }
 
-               adj = gtk_adjustment_new(current_value,
+               adj = gtk_adjustment_new (current_value,
                                         r_min, r_max,
                                         1.0, 1.0, 1.0 /* steps */
                                         );
 
-               gtk_sheet_change_entry(sheet, GTK_TYPE_SPIN_BUTTON);
+               gtk_sheet_change_entry (sheet, GTK_TYPE_SPIN_BUTTON);
 
                spinButton =
-                 GTK_SPIN_BUTTON(gtk_sheet_get_entry(sheet));
+                 GTK_SPIN_BUTTON(gtk_sheet_get_entry (sheet));
 
-               gtk_spin_button_set_adjustment(spinButton, GTK_ADJUSTMENT(adj));
-               gtk_spin_button_set_digits(spinButton, 0);
+               gtk_spin_button_set_adjustment (spinButton, GTK_ADJUSTMENT(adj));
+               gtk_spin_button_set_digits (spinButton, 0);
              }
          }
       }
       break;
 
     default:
-      gtk_sheet_change_entry(sheet, GTK_TYPE_ENTRY);
+      gtk_sheet_change_entry (sheet, GTK_TYPE_ENTRY);
       break;
     }
 
@@ -420,11 +420,11 @@ psppire_variable_sheet_create (gchar *widget_name,
   gint i;
   GtkWidget *sheet;
 
-  GObject *geo = g_sheet_hetero_column_new(75, n_COLS);
+  GObject *geo = g_sheet_hetero_column_new (75, n_COLS);
 
   g_assert (the_var_store);
 
-  sheet = gtk_sheet_new(G_SHEET_ROW(the_var_store),
+  sheet = gtk_sheet_new (G_SHEET_ROW(the_var_store),
                        G_SHEET_COLUMN(geo),
                        "variable sheet", 0);
 
@@ -441,24 +441,24 @@ psppire_variable_sheet_create (gchar *widget_name,
                    GTK_SIGNAL_FUNC (traverse_cell_callback), 0);
 
 
-  gtk_sheet_set_model(sheet, G_SHEET_MODEL(the_var_store));
+  gtk_sheet_set_model (sheet, G_SHEET_MODEL(the_var_store));
 
 
   /* Since this happens inside glade_xml_new, we must prevent strings from
    * being re-encoded twice */
-  codeset = bind_textdomain_codeset(PACKAGE, 0);
-  bind_textdomain_codeset(PACKAGE, nl_langinfo(CODESET));
+  codeset = bind_textdomain_codeset (PACKAGE, 0);
+  bind_textdomain_codeset (PACKAGE, nl_langinfo (CODESET));
   for (i = 0 ; i < n_COLS ; ++i )
     {
-      g_sheet_hetero_column_set_button_label(G_SHEET_HETERO_COLUMN(geo), i,
-                       gettext(column_def[i].label));
+      g_sheet_hetero_column_set_button_label (G_SHEET_HETERO_COLUMN(geo), i,
+                       gettext (column_def[i].label));
 
-      g_sheet_hetero_column_set_width(G_SHEET_HETERO_COLUMN(geo), i,
+      g_sheet_hetero_column_set_width (G_SHEET_HETERO_COLUMN(geo), i,
                                               column_def[i].width);
     }
-  bind_textdomain_codeset(PACKAGE, codeset);
+  bind_textdomain_codeset (PACKAGE, codeset);
 
-  gtk_widget_show(sheet);
+  gtk_widget_show (sheet);
 
   return sheet;
 }
index 4ef83dc8ee44c25ba12600ef227ae338e6c57c62..0fabaa82aea271dfad16c4d2a1fe59552e570996 100644 (file)
@@ -38,7 +38,7 @@ enum {COL_NAME,
       n_COLS};
 
 
-void var_sheet_range_set_editable(GtkSheet *sheet,
+void var_sheet_range_set_editable (GtkSheet *sheet,
                                  const GtkSheetRange *urange,
                                  gboolean editable);
 
index 48b6e988dce3b9f3ebe5a928c14cb880d4ca68f3..2bee901bb5c7f217cdeda64690526c1e0df00ce5 100644 (file)
@@ -102,23 +102,23 @@ static const int cc_format[] =
 static void select_treeview_from_format
  (GtkTreeView *treeview, const struct fmt_spec *fmt);
 
-static void select_treeview_from_format_type(GtkTreeView *treeview,
+static void select_treeview_from_format_type (GtkTreeView *treeview,
                                             const int fmt_type);
 
 
 /* callback for when any of the radio buttons are toggled */
 static void
-on_toggle_1(GtkToggleButton *togglebutton, gpointer user_data)
+on_toggle_1 (GtkToggleButton *togglebutton, gpointer user_data)
 {
   struct tgs *tgs = user_data;
 
-  if ( gtk_toggle_button_get_active(togglebutton) == FALSE)
+  if ( gtk_toggle_button_get_active (togglebutton) == FALSE)
     return ;
 
   tgs->dialog->active_button = tgs->button;
 }
 
-static void update_width_decimals(const struct var_type_dialog *dialog);
+static void update_width_decimals (const struct var_type_dialog *dialog);
 
 #define force_max(x, val) if (x > val) x = val
 
@@ -126,18 +126,18 @@ static void update_width_decimals(const struct var_type_dialog *dialog);
    Set the local format from the variable
    and force them to have sensible values */
 static void
-set_local_width_decimals(struct var_type_dialog *dialog)
+set_local_width_decimals (struct var_type_dialog *dialog)
 {
   dialog->fmt_l = * var_get_write_format (dialog->pv);
 
   switch (dialog->active_button)
     {
     case BUTTON_STRING:
-      force_max( dialog->fmt_l.w, 255);
+      force_max ( dialog->fmt_l.w, 255);
       break;
     default:
-      force_max( dialog->fmt_l.w, 40);
-      force_max( dialog->fmt_l.d, 16);
+      force_max ( dialog->fmt_l.w, 40);
+      force_max ( dialog->fmt_l.d, 16);
       break;
     }
 }
@@ -145,99 +145,99 @@ set_local_width_decimals(struct var_type_dialog *dialog)
 
 /* callback for when any of the radio buttons are toggled */
 static void
-on_toggle_2(GtkToggleButton *togglebutton, gpointer user_data)
+on_toggle_2 (GtkToggleButton *togglebutton, gpointer user_data)
 {
   struct var_type_dialog *dialog = user_data;
-  if ( gtk_toggle_button_get_active(togglebutton) == FALSE)
+  if ( gtk_toggle_button_get_active (togglebutton) == FALSE)
     {
       switch (dialog->active_button)
        {
        case BUTTON_DATE:
-         gtk_widget_hide(dialog->date_format_list);
+         gtk_widget_hide (dialog->date_format_list);
          break;
        case BUTTON_CUSTOM:
-         gtk_widget_hide(dialog->custom_currency_hbox);
+         gtk_widget_hide (dialog->custom_currency_hbox);
          break;
        case BUTTON_DOLLAR:
-         gtk_widget_hide(dialog->dollar_window);
+         gtk_widget_hide (dialog->dollar_window);
          break;
        case BUTTON_STRING:
-         gtk_widget_show(dialog->label_decimals);
-         gtk_widget_show(dialog->entry_decimals);
+         gtk_widget_show (dialog->label_decimals);
+         gtk_widget_show (dialog->entry_decimals);
          break;
        }
       return ;
     }
 
-  set_local_width_decimals(dialog);
-  update_width_decimals(dialog);
+  set_local_width_decimals (dialog);
+  update_width_decimals (dialog);
 
   switch (dialog->active_button)
     {
     case BUTTON_STRING:
-      gtk_widget_show(dialog->width_decimals);
-      gtk_widget_hide(dialog->label_decimals);
-      gtk_widget_hide(dialog->entry_decimals);
+      gtk_widget_show (dialog->width_decimals);
+      gtk_widget_hide (dialog->label_decimals);
+      gtk_widget_hide (dialog->entry_decimals);
       break;
     case BUTTON_DATE:
-      select_treeview_from_format(dialog->date_format_treeview,
+      select_treeview_from_format (dialog->date_format_treeview,
                                  &format_option[0].spec);
-      gtk_widget_hide(dialog->width_decimals);
-      gtk_widget_show(dialog->date_format_list);
+      gtk_widget_hide (dialog->width_decimals);
+      gtk_widget_show (dialog->date_format_list);
       break;
     case BUTTON_DOLLAR:
-      select_treeview_from_format(dialog->dollar_treeview,
+      select_treeview_from_format (dialog->dollar_treeview,
                                  &dollar_format[0]);
-      gtk_widget_show(dialog->dollar_window);
-      gtk_widget_show_all(dialog->width_decimals);
+      gtk_widget_show (dialog->dollar_window);
+      gtk_widget_show_all (dialog->width_decimals);
       break;
     case BUTTON_CUSTOM:
-      select_treeview_from_format_type(dialog->custom_treeview,
+      select_treeview_from_format_type (dialog->custom_treeview,
                                  cc_format[0]);
 
-      gtk_widget_show(dialog->width_decimals);
-      gtk_widget_show(dialog->custom_currency_hbox);
+      gtk_widget_show (dialog->width_decimals);
+      gtk_widget_show (dialog->custom_currency_hbox);
       break;
     default:
-      gtk_widget_show_all(dialog->width_decimals);
+      gtk_widget_show_all (dialog->width_decimals);
       break;
     }
 }
 
 
 
-static gint on_var_type_ok_clicked(GtkWidget *w, gpointer data);
+static gint on_var_type_ok_clicked (GtkWidget *w, gpointer data);
 
 #define LEN 20
 
 static void
-add_to_group(GtkWidget *w, gpointer data)
+add_to_group (GtkWidget *w, gpointer data)
 {
   GtkSizeGroup *sg = data;
 
-  gtk_size_group_add_widget(sg, w);
+  gtk_size_group_add_widget (sg, w);
 }
 
 /* Set the local width and decimals entry boxes to reflec the local format */
 static void
-update_width_decimals(const struct var_type_dialog *dialog)
+update_width_decimals (const struct var_type_dialog *dialog)
 {
   gchar *text;
-  g_assert(dialog);
+  g_assert (dialog);
 
-  text = g_strdup_printf("%d", dialog->fmt_l.w);
-  gtk_entry_set_text(GTK_ENTRY(dialog->entry_width), text);
-  g_free(text);
+  text = g_strdup_printf ("%d", dialog->fmt_l.w);
+  gtk_entry_set_text (GTK_ENTRY(dialog->entry_width), text);
+  g_free (text);
 
-  text = g_strdup_printf("%d", dialog->fmt_l.d);
-  gtk_entry_set_text(GTK_ENTRY(dialog->entry_decimals), text);
-  g_free(text);
+  text = g_strdup_printf ("%d", dialog->fmt_l.d);
+  gtk_entry_set_text (GTK_ENTRY(dialog->entry_decimals), text);
+  g_free (text);
 }
 
 /* Callback for when the custom treeview row is changed.
    It sets dialog box to reflect the selected format */
 static void
-preview_custom(GtkWidget *w, gpointer data)
+preview_custom (GtkWidget *w, gpointer data)
 {
   const gchar *text ;
 
@@ -246,17 +246,17 @@ preview_custom(GtkWidget *w, gpointer data)
   if ( dialog->active_button != BUTTON_CUSTOM )
     return;
 
-  text = gtk_entry_get_text(GTK_ENTRY(dialog->entry_decimals));
-  dialog->fmt_l.d = atoi(text);
+  text = gtk_entry_get_text (GTK_ENTRY(dialog->entry_decimals));
+  dialog->fmt_l.d = atoi (text);
 
-  text = gtk_entry_get_text(GTK_ENTRY(dialog->entry_width));
-  dialog->fmt_l.w = atoi(text);
+  text = gtk_entry_get_text (GTK_ENTRY(dialog->entry_width));
+  dialog->fmt_l.w = atoi (text);
 
   msg_disable ();
-  if ( ! fmt_check_output(&dialog->fmt_l))
+  if ( ! fmt_check_output (&dialog->fmt_l))
     {
-      gtk_label_set_text(GTK_LABEL(dialog->label_psample), "---");
-      gtk_label_set_text(GTK_LABEL(dialog->label_nsample), "---");
+      gtk_label_set_text (GTK_LABEL(dialog->label_psample), "---");
+      gtk_label_set_text (GTK_LABEL(dialog->label_nsample), "---");
     }
   else
     {
@@ -264,14 +264,14 @@ preview_custom(GtkWidget *w, gpointer data)
       union value v;
       v.f = 1234.56;
 
-      sample_text = value_to_text(v, dialog->fmt_l);
-      gtk_label_set_text(GTK_LABEL(dialog->label_psample), sample_text);
-      g_free(sample_text);
+      sample_text = value_to_text (v, dialog->fmt_l);
+      gtk_label_set_text (GTK_LABEL(dialog->label_psample), sample_text);
+      g_free (sample_text);
 
       v.f = -v.f;
-      sample_text = value_to_text(v, dialog->fmt_l);
-      gtk_label_set_text(GTK_LABEL(dialog->label_nsample), sample_text);
-      g_free(sample_text);
+      sample_text = value_to_text (v, dialog->fmt_l);
+      gtk_label_set_text (GTK_LABEL(dialog->label_nsample), sample_text);
+      g_free (sample_text);
     }
   msg_enable ();
 }
@@ -279,44 +279,44 @@ preview_custom(GtkWidget *w, gpointer data)
 /* Callback for when a treeview row is changed.
    It sets the fmt_l_spec to reflect the selected format */
 static void
-set_format_from_treeview(GtkTreeView *treeview, gpointer data)
+set_format_from_treeview (GtkTreeView *treeview, gpointer data)
 {
   struct var_type_dialog *dialog = data;
   GtkTreeIter iter ;
   GValue the_value = {0};
 
-  GtkTreeSelection* sel =  gtk_tree_view_get_selection(treeview);
+  GtkTreeSelection* sel =  gtk_tree_view_get_selection (treeview);
 
-  GtkTreeModel * model  = gtk_tree_view_get_model(treeview);
+  GtkTreeModel * model  = gtk_tree_view_get_model (treeview);
 
   gtk_tree_selection_get_selected (sel, &model, &iter);
 
-  gtk_tree_model_get_value(model, &iter, 1, &the_value);
+  gtk_tree_model_get_value (model, &iter, 1, &the_value);
 
-  dialog->fmt_l = *(struct fmt_spec *) g_value_get_pointer(&the_value);
+  dialog->fmt_l = *(struct fmt_spec *) g_value_get_pointer (&the_value);
 }
 
 
 /* Callback for when a treeview row is changed.
    It sets the type of the fmt_l to reflect the selected type */
 static void
-set_format_type_from_treeview(GtkTreeView *treeview, gpointer data)
+set_format_type_from_treeview (GtkTreeView *treeview, gpointer data)
 {
   static struct fmt_spec custom_format = {0,0,0};
   struct var_type_dialog *dialog = data;
   GtkTreeIter iter ;
   GValue the_value = {0};
 
-  GtkTreeSelection* sel =  gtk_tree_view_get_selection(treeview);
+  GtkTreeSelection* sel =  gtk_tree_view_get_selection (treeview);
 
-  GtkTreeModel * model  = gtk_tree_view_get_model(treeview);
+  GtkTreeModel * model  = gtk_tree_view_get_model (treeview);
 
   gtk_tree_selection_get_selected (sel, &model, &iter);
 
-  gtk_tree_model_get_value(model, &iter, 1, &the_value);
+  gtk_tree_model_get_value (model, &iter, 1, &the_value);
 
   dialog->fmt_l = custom_format;
-  dialog->fmt_l.type = *(int*) g_value_get_pointer(&the_value);
+  dialog->fmt_l.type = *(int*) g_value_get_pointer (&the_value);
 
 }
 
@@ -328,56 +328,56 @@ struct var_type_dialog *
 var_type_dialog_create (GladeXML *xml)
 {
   gint i;
-  struct var_type_dialog *dialog = g_malloc(sizeof(struct var_type_dialog));
+  struct var_type_dialog *dialog = g_malloc (sizeof (struct var_type_dialog));
 
-  g_assert(xml);
+  g_assert (xml);
 
-  dialog->window = get_widget_assert(xml,"var_type_dialog");
+  dialog->window = get_widget_assert (xml,"var_type_dialog");
 
-  gtk_window_set_transient_for(GTK_WINDOW(dialog->window),
-                              GTK_WINDOW(get_widget_assert(xml, "data_editor")));
+  gtk_window_set_transient_for (GTK_WINDOW(dialog->window),
+                              GTK_WINDOW(get_widget_assert (xml, "data_editor")));
 
   dialog->radioButton[BUTTON_NUMERIC] =
-    get_widget_assert(xml,"radiobutton1");
+    get_widget_assert (xml,"radiobutton1");
   dialog->radioButton[BUTTON_COMMA] =
-    get_widget_assert(xml,"radiobutton2");
+    get_widget_assert (xml,"radiobutton2");
   dialog->radioButton[BUTTON_DOT] =
-    get_widget_assert(xml,"radiobutton3");
+    get_widget_assert (xml,"radiobutton3");
   dialog->radioButton[BUTTON_SCIENTIFIC] =
-    get_widget_assert(xml,"radiobutton4");
+    get_widget_assert (xml,"radiobutton4");
   dialog->radioButton[BUTTON_DATE] =
-    get_widget_assert(xml,"radiobutton5");
+    get_widget_assert (xml,"radiobutton5");
   dialog->radioButton[BUTTON_DOLLAR] =
-    get_widget_assert(xml,"radiobutton6");
+    get_widget_assert (xml,"radiobutton6");
   dialog->radioButton[BUTTON_CUSTOM] =
-    get_widget_assert(xml,"radiobutton7");
+    get_widget_assert (xml,"radiobutton7");
   dialog->radioButton[BUTTON_STRING] =
-    get_widget_assert(xml,"radiobutton8");
+    get_widget_assert (xml,"radiobutton8");
 
 
-  dialog->date_format_list = get_widget_assert(xml, "scrolledwindow4");
-  dialog->width_decimals = get_widget_assert(xml, "width_decimals");
-  dialog->label_decimals = get_widget_assert(xml, "decimals_label");
-  dialog->entry_decimals = get_widget_assert(xml, "decimals_entry");
+  dialog->date_format_list = get_widget_assert (xml, "scrolledwindow4");
+  dialog->width_decimals = get_widget_assert (xml, "width_decimals");
+  dialog->label_decimals = get_widget_assert (xml, "decimals_label");
+  dialog->entry_decimals = get_widget_assert (xml, "decimals_entry");
 
-  dialog->label_psample = get_widget_assert(xml, "psample_label");
-  dialog->label_nsample = get_widget_assert(xml, "nsample_label");
+  dialog->label_psample = get_widget_assert (xml, "psample_label");
+  dialog->label_nsample = get_widget_assert (xml, "nsample_label");
 
 
-  dialog->entry_width = get_widget_assert(xml,"width_entry");
+  dialog->entry_width = get_widget_assert (xml,"width_entry");
 
-  dialog->custom_currency_hbox = get_widget_assert(xml,
+  dialog->custom_currency_hbox = get_widget_assert (xml,
                                                   "custom_currency_hbox");
 
-  dialog->dollar_window = get_widget_assert(xml, "dollar_window");
+  dialog->dollar_window = get_widget_assert (xml, "dollar_window");
   dialog->dollar_treeview =
-    GTK_TREE_VIEW(get_widget_assert(xml, "dollar_treeview"));
+    GTK_TREE_VIEW(get_widget_assert (xml, "dollar_treeview"));
 
   dialog->custom_treeview =
-    GTK_TREE_VIEW(get_widget_assert(xml, "custom_treeview"));
+    GTK_TREE_VIEW(get_widget_assert (xml, "custom_treeview"));
 
 
-  dialog->ok = get_widget_assert(xml,"var_type_ok");
+  dialog->ok = get_widget_assert (xml,"var_type_ok");
 
 
   {
@@ -392,9 +392,9 @@ var_type_dialog_create (GladeXML *xml)
      However only one child is ever shown at a time.
      We need to make sure that they all have the same width, to avoid
      upleasant resizing effects */
-  GtkSizeGroup *sizeGroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
+  GtkSizeGroup *sizeGroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
 
-  gtk_container_foreach(GTK_CONTAINER(get_widget_assert(xml, "middle_box")),
+  gtk_container_foreach (GTK_CONTAINER(get_widget_assert (xml, "middle_box")),
                        add_to_group, sizeGroup);
 
 
@@ -402,18 +402,18 @@ var_type_dialog_create (GladeXML *xml)
     {
       tgs[i].dialog = dialog;
       tgs[i].button = i;
-      g_signal_connect(dialog->radioButton[i], "toggled",
+      g_signal_connect (dialog->radioButton[i], "toggled",
                       G_CALLBACK(on_toggle_1), &tgs[i]);
 
-      g_signal_connect(dialog->radioButton[i], "toggled",
+      g_signal_connect (dialog->radioButton[i], "toggled",
                       G_CALLBACK(on_toggle_2), dialog);
     }
 
   /* Populate the date format tree view */
-  dialog->date_format_treeview = GTK_TREE_VIEW(get_widget_assert(xml,
+  dialog->date_format_treeview = GTK_TREE_VIEW(get_widget_assert (xml,
                                              "date_format_list_view"));
 
-  renderer = gtk_cell_renderer_text_new();
+  renderer = gtk_cell_renderer_text_new ();
 
   column = gtk_tree_view_column_new_with_attributes ("Title",
                                                     renderer,
@@ -427,7 +427,7 @@ var_type_dialog_create (GladeXML *xml)
 
   list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
 
-  for ( i = 0 ; i < sizeof(format_option) / sizeof(format_option[0]) ; ++i )
+  for ( i = 0 ; i < sizeof (format_option) / sizeof (format_option[0]) ; ++i )
     {
       gtk_list_store_append (list_store, &iter);
       gtk_list_store_set (list_store, &iter,
@@ -436,18 +436,18 @@ var_type_dialog_create (GladeXML *xml)
                          -1);
     }
 
-  gtk_tree_view_set_model(GTK_TREE_VIEW(dialog->date_format_treeview),
+  gtk_tree_view_set_model (GTK_TREE_VIEW(dialog->date_format_treeview),
                          GTK_TREE_MODEL(list_store));
 
-  g_object_unref(list_store);
+  g_object_unref (list_store);
 
-  g_signal_connect(GTK_OBJECT(dialog->date_format_treeview), "cursor-changed",
+  g_signal_connect (GTK_OBJECT(dialog->date_format_treeview), "cursor-changed",
                   GTK_SIGNAL_FUNC(set_format_from_treeview), dialog);
 
 
   /* populate the dollar treeview */
 
-  renderer = gtk_cell_renderer_text_new();
+  renderer = gtk_cell_renderer_text_new ();
 
   column = gtk_tree_view_column_new_with_attributes ("Title",
                                                     renderer,
@@ -462,7 +462,7 @@ var_type_dialog_create (GladeXML *xml)
   list_store = gtk_list_store_new (2, G_TYPE_STRING,
                                                 G_TYPE_POINTER);
 
-  for ( i = 0 ; i < sizeof(dollar_format)/sizeof(dollar_format[0]) ; ++i )
+  for ( i = 0 ; i < sizeof (dollar_format)/sizeof (dollar_format[0]) ; ++i )
     {
       char *template = fmt_dollar_template (&dollar_format[i]);
       gtk_list_store_append (list_store, &iter);
@@ -473,23 +473,23 @@ var_type_dialog_create (GladeXML *xml)
       free (template);
     }
 
-  gtk_tree_view_set_model(GTK_TREE_VIEW(dialog->dollar_treeview),
+  gtk_tree_view_set_model (GTK_TREE_VIEW(dialog->dollar_treeview),
                          GTK_TREE_MODEL(list_store));
 
-  g_object_unref(list_store);
+  g_object_unref (list_store);
 
-  g_signal_connect(GTK_OBJECT(dialog->dollar_treeview),
+  g_signal_connect (GTK_OBJECT(dialog->dollar_treeview),
                   "cursor-changed",
                   GTK_SIGNAL_FUNC(set_format_from_treeview), dialog);
 
-  g_signal_connect_swapped(GTK_OBJECT(dialog->dollar_treeview),
+  g_signal_connect_swapped (GTK_OBJECT(dialog->dollar_treeview),
                   "cursor-changed",
                   GTK_SIGNAL_FUNC(update_width_decimals), dialog);
 
 
   /* populate the custom treeview */
 
-  renderer = gtk_cell_renderer_text_new();
+  renderer = gtk_cell_renderer_text_new ();
 
   column = gtk_tree_view_column_new_with_attributes ("Title",
                                                     renderer,
@@ -508,7 +508,7 @@ var_type_dialog_create (GladeXML *xml)
     {
       enum fmt_type cc_fmts[5] = {FMT_CCA, FMT_CCB, FMT_CCC, FMT_CCD, FMT_CCE};
       gchar text[4];
-      g_snprintf(text, 4, "%s", fmt_name (cc_fmts[i]));
+      g_snprintf (text, 4, "%s", fmt_name (cc_fmts[i]));
       gtk_list_store_append (list_store, &iter);
       gtk_list_store_set (list_store, &iter,
                           0, text,
@@ -516,34 +516,34 @@ var_type_dialog_create (GladeXML *xml)
                          -1);
     }
 
-  gtk_tree_view_set_model(GTK_TREE_VIEW(dialog->custom_treeview),
+  gtk_tree_view_set_model (GTK_TREE_VIEW(dialog->custom_treeview),
                          GTK_TREE_MODEL(list_store));
 
-  g_object_unref(list_store);
+  g_object_unref (list_store);
 
 
-  g_signal_connect(GTK_OBJECT(dialog->custom_treeview),
+  g_signal_connect (GTK_OBJECT(dialog->custom_treeview),
                   "cursor-changed",
                   GTK_SIGNAL_FUNC(set_format_type_from_treeview), dialog);
 
 
-  g_signal_connect(GTK_OBJECT(dialog->custom_treeview),
+  g_signal_connect (GTK_OBJECT(dialog->custom_treeview),
                   "cursor-changed",
                   GTK_SIGNAL_FUNC(preview_custom), dialog);
 
 
-  g_signal_connect(GTK_OBJECT(dialog->entry_width),
+  g_signal_connect (GTK_OBJECT(dialog->entry_width),
                   "changed",
                   GTK_SIGNAL_FUNC(preview_custom), dialog);
 
 
-  g_signal_connect(GTK_OBJECT(dialog->entry_decimals),
+  g_signal_connect (GTK_OBJECT(dialog->entry_decimals),
                   "changed",
                   GTK_SIGNAL_FUNC(preview_custom), dialog);
 
 
   /* Connect the OK button */
-  g_signal_connect(dialog->ok, "clicked", G_CALLBACK(on_var_type_ok_clicked),
+  g_signal_connect (dialog->ok, "clicked", G_CALLBACK(on_var_type_ok_clicked),
                   dialog);
 
 
@@ -555,9 +555,9 @@ var_type_dialog_create (GladeXML *xml)
 
 /* Set a particular button to be active */
 void
-var_type_dialog_set_active_button(struct var_type_dialog *dialog, gint b)
+var_type_dialog_set_active_button (struct var_type_dialog *dialog, gint b)
 {
-  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->radioButton[b]),
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(dialog->radioButton[b]),
                               TRUE);
   dialog->active_button = b;
 }
@@ -566,7 +566,7 @@ var_type_dialog_set_active_button(struct var_type_dialog *dialog, gint b)
 
 /* Set the TREEVIEW list cursor to the item described by FMT */
 static void
-select_treeview_from_format(GtkTreeView *treeview, const struct fmt_spec *fmt)
+select_treeview_from_format (GtkTreeView *treeview, const struct fmt_spec *fmt)
 {
   GtkTreePath *path ;
 
@@ -575,44 +575,44 @@ select_treeview_from_format(GtkTreeView *treeview, const struct fmt_spec *fmt)
     efficient, but the list is short ... */
   GtkTreeIter iter;
 
-  GtkTreeModel * model  = gtk_tree_view_get_model(treeview);
+  GtkTreeModel * model  = gtk_tree_view_get_model (treeview);
 
   gboolean success;
-  for (success = gtk_tree_model_get_iter_first(model, &iter);
+  for (success = gtk_tree_model_get_iter_first (model, &iter);
        success;
-       success = gtk_tree_model_iter_next(model, &iter))
+       success = gtk_tree_model_iter_next (model, &iter))
     {
       const struct fmt_spec *spec;
 
       GValue value = {0};
 
-      gtk_tree_model_get_value(model, &iter, 1, &value);
+      gtk_tree_model_get_value (model, &iter, 1, &value);
 
-      spec = g_value_get_pointer(&value);
+      spec = g_value_get_pointer (&value);
 
-      if ( 0 == memcmp(spec, fmt, sizeof (struct fmt_spec)))
+      if ( 0 == memcmp (spec, fmt, sizeof (struct fmt_spec)))
        {
          break;
        }
     }
 
-  path = gtk_tree_model_get_path(model, &iter);
+  path = gtk_tree_model_get_path (model, &iter);
   if ( path )
     {
-      gtk_tree_view_set_cursor(treeview, path, 0, 0);
-      gtk_tree_path_free(path);
+      gtk_tree_view_set_cursor (treeview, path, 0, 0);
+      gtk_tree_path_free (path);
     }
   else
     {
       char str[FMT_STRING_LEN_MAX + 1];
-      g_warning("Unusual date format: %s\n", fmt_to_string(fmt, str));
+      g_warning ("Unusual date format: %s\n", fmt_to_string (fmt, str));
     }
 }
 
 
 /* Set the TREEVIEW list cursor to the item described by FMT_TYPE */
 static void
-select_treeview_from_format_type(GtkTreeView *treeview,
+select_treeview_from_format_type (GtkTreeView *treeview,
                                 const int fmt_type)
 {
   GtkTreePath *path ;
@@ -622,86 +622,86 @@ select_treeview_from_format_type(GtkTreeView *treeview,
     efficient, but the list is short ... */
   GtkTreeIter iter;
 
-  GtkTreeModel * model  = gtk_tree_view_get_model(treeview);
+  GtkTreeModel * model  = gtk_tree_view_get_model (treeview);
 
   gboolean success;
-  for (success = gtk_tree_model_get_iter_first(model, &iter);
+  for (success = gtk_tree_model_get_iter_first (model, &iter);
        success;
-       success = gtk_tree_model_iter_next(model, &iter))
+       success = gtk_tree_model_iter_next (model, &iter))
     {
       int spec ;
 
       GValue value = {0};
 
-      gtk_tree_model_get_value(model, &iter, 1, &value);
+      gtk_tree_model_get_value (model, &iter, 1, &value);
 
-      spec = * ((int *) g_value_get_pointer(&value));
+      spec = * ((int *) g_value_get_pointer (&value));
 
       if ( spec == fmt_type)
        break;
     }
 
-  path = gtk_tree_model_get_path(model, &iter);
+  path = gtk_tree_model_get_path (model, &iter);
   if ( path )
     {
-      gtk_tree_view_set_cursor(treeview, path, 0, 0);
-      gtk_tree_path_free(path);
+      gtk_tree_view_set_cursor (treeview, path, 0, 0);
+      gtk_tree_path_free (path);
     }
   else
-    g_warning("Unknown custom type  %d\n", fmt_type);
+    g_warning ("Unknown custom type  %d\n", fmt_type);
 
 }
 
 /* Set up the state of the dialog box to match the variable VAR */
 static void
-var_type_dialog_set_state(struct var_type_dialog *dialog)
+var_type_dialog_set_state (struct var_type_dialog *dialog)
 {
   const struct fmt_spec *write_spec ;
-  GString *str = g_string_new("");
+  GString *str = g_string_new ("");
 
-  g_assert(dialog);
-  g_assert(dialog->pv);
+  g_assert (dialog);
+  g_assert (dialog->pv);
 
   /* Populate width and decimals */
   write_spec = var_get_write_format (dialog->pv);
 
-  g_string_printf(str, "%d", write_spec->d);
+  g_string_printf (str, "%d", write_spec->d);
 
-  gtk_entry_set_text(GTK_ENTRY(dialog->entry_decimals),
+  gtk_entry_set_text (GTK_ENTRY(dialog->entry_decimals),
                     str->str);
 
-  g_string_printf(str, "%d", write_spec->w);
+  g_string_printf (str, "%d", write_spec->w);
 
-  gtk_entry_set_text(GTK_ENTRY(dialog->entry_width),
+  gtk_entry_set_text (GTK_ENTRY(dialog->entry_width),
                     str->str);
 
-  g_string_free(str, TRUE);
+  g_string_free (str, TRUE);
 
   /* Populate the radio button states */
   switch (write_spec->type)
     {
     case FMT_F:
-      var_type_dialog_set_active_button(dialog, BUTTON_NUMERIC);
-      gtk_widget_show_all(dialog->width_decimals);
+      var_type_dialog_set_active_button (dialog, BUTTON_NUMERIC);
+      gtk_widget_show_all (dialog->width_decimals);
       break;
     case FMT_A:
-      var_type_dialog_set_active_button(dialog, BUTTON_STRING);
-      gtk_widget_hide(dialog->label_decimals);
-      gtk_widget_hide(dialog->entry_decimals);
+      var_type_dialog_set_active_button (dialog, BUTTON_STRING);
+      gtk_widget_hide (dialog->label_decimals);
+      gtk_widget_hide (dialog->entry_decimals);
       break;
     case FMT_COMMA:
-      var_type_dialog_set_active_button(dialog, BUTTON_COMMA);
-      gtk_widget_show_all(dialog->width_decimals);
+      var_type_dialog_set_active_button (dialog, BUTTON_COMMA);
+      gtk_widget_show_all (dialog->width_decimals);
       break;
     case FMT_DOT:
-      var_type_dialog_set_active_button(dialog, BUTTON_DOT);
-      gtk_widget_show_all(dialog->width_decimals);
+      var_type_dialog_set_active_button (dialog, BUTTON_DOT);
+      gtk_widget_show_all (dialog->width_decimals);
       break;
     case FMT_DOLLAR:
-      var_type_dialog_set_active_button(dialog, BUTTON_DOLLAR);
-      gtk_widget_show_all(dialog->width_decimals);
+      var_type_dialog_set_active_button (dialog, BUTTON_DOLLAR);
+      gtk_widget_show_all (dialog->width_decimals);
 
-      select_treeview_from_format(dialog->dollar_treeview, write_spec);
+      select_treeview_from_format (dialog->dollar_treeview, write_spec);
       break;
     case FMT_DATE:
     case FMT_EDATE:
@@ -716,23 +716,23 @@ var_type_dialog_set_state(struct var_type_dialog *dialog)
     case FMT_DTIME:
     case FMT_WKDAY:
     case FMT_MONTH:
-      var_type_dialog_set_active_button(dialog, BUTTON_DATE);
-      gtk_widget_hide(dialog->width_decimals);
-      gtk_widget_show(dialog->date_format_list);
-      select_treeview_from_format(dialog->date_format_treeview, write_spec);
+      var_type_dialog_set_active_button (dialog, BUTTON_DATE);
+      gtk_widget_hide (dialog->width_decimals);
+      gtk_widget_show (dialog->date_format_list);
+      select_treeview_from_format (dialog->date_format_treeview, write_spec);
       break;
     case FMT_CCA:
     case FMT_CCB:
     case FMT_CCC:
     case FMT_CCD:
     case FMT_CCE:
-      var_type_dialog_set_active_button(dialog, BUTTON_CUSTOM);
-      select_treeview_from_format_type(dialog->custom_treeview,
+      var_type_dialog_set_active_button (dialog, BUTTON_CUSTOM);
+      select_treeview_from_format_type (dialog->custom_treeview,
                                       write_spec->type);
-      gtk_widget_show_all(dialog->width_decimals);
+      gtk_widget_show_all (dialog->width_decimals);
       break;
     default:
-      gtk_widget_show_all(dialog->width_decimals);
+      gtk_widget_show_all (dialog->width_decimals);
       break;
     }
 }
@@ -740,11 +740,11 @@ var_type_dialog_set_state(struct var_type_dialog *dialog)
 
 /* Popup the dialog box */
 void
-var_type_dialog_show(struct var_type_dialog *dialog)
+var_type_dialog_show (struct var_type_dialog *dialog)
 {
-  var_type_dialog_set_state(dialog);
+  var_type_dialog_set_state (dialog);
 
-  gtk_widget_show(dialog->window);
+  gtk_widget_show (dialog->window);
 }
 
 /* Fills F with an output format specification with type TYPE, width
@@ -767,18 +767,18 @@ make_output_format_try (struct fmt_spec *f, int type, int w, int d)
 /* Callback for when the var type dialog is closed using the OK button.
    It sets the appropriate variable accordingly. */
 static gint
-on_var_type_ok_clicked(GtkWidget *w, gpointer data)
+on_var_type_ok_clicked (GtkWidget *w, gpointer data)
 {
   struct var_type_dialog *dialog = data;
 
-  g_assert(dialog);
-  g_assert(dialog->pv);
+  g_assert (dialog);
+  g_assert (dialog->pv);
 
   {
-    gint width = atoi(gtk_entry_get_text
+    gint width = atoi (gtk_entry_get_text
                      (GTK_ENTRY(dialog->entry_width)));
 
-    gint decimals = atoi(gtk_entry_get_text
+    gint decimals = atoi (gtk_entry_get_text
                         (GTK_ENTRY(dialog->entry_decimals)));
 
     gint new_type = VAR_NUMERIC;
@@ -790,30 +790,30 @@ on_var_type_ok_clicked(GtkWidget *w, gpointer data)
       case BUTTON_STRING:
        new_type = VAR_STRING;
        new_width = width;
-       result = make_output_format_try(&spec, FMT_A, width, 0);
+       result = make_output_format_try (&spec, FMT_A, width, 0);
        break;
       case BUTTON_NUMERIC:
-       result = make_output_format_try(&spec, FMT_F, width, decimals);
+       result = make_output_format_try (&spec, FMT_F, width, decimals);
        break;
       case BUTTON_COMMA:
-       result = make_output_format_try(&spec, FMT_COMMA, width, decimals);
+       result = make_output_format_try (&spec, FMT_COMMA, width, decimals);
        break;
       case BUTTON_DOT:
-       result = make_output_format_try(&spec, FMT_DOT, width, decimals);
+       result = make_output_format_try (&spec, FMT_DOT, width, decimals);
        break;
       case BUTTON_SCIENTIFIC:
-       result = make_output_format_try(&spec, FMT_E, width, decimals);
+       result = make_output_format_try (&spec, FMT_E, width, decimals);
        break;
       case BUTTON_DATE:
       case BUTTON_CUSTOM:
-       g_assert(fmt_check_output(&dialog->fmt_l));
-       result = memcpy(&spec, &dialog->fmt_l, sizeof(struct fmt_spec));
+       g_assert (fmt_check_output (&dialog->fmt_l));
+       result = memcpy (&spec, &dialog->fmt_l, sizeof (struct fmt_spec));
        break;
       case BUTTON_DOLLAR:
-       result = make_output_format_try(&spec, FMT_DOLLAR, width, decimals);
+       result = make_output_format_try (&spec, FMT_DOLLAR, width, decimals);
        break;
       default:
-       g_print("Unknown variable type: %d\n", dialog->active_button) ;
+       g_print ("Unknown variable type: %d\n", dialog->active_button) ;
        result = false;
        break;
       }
@@ -825,7 +825,7 @@ on_var_type_ok_clicked(GtkWidget *w, gpointer data)
       }
 
   }
-  gtk_widget_hide(dialog->window);
+  gtk_widget_hide (dialog->window);
 
   return FALSE;
 }
@@ -833,9 +833,9 @@ on_var_type_ok_clicked(GtkWidget *w, gpointer data)
 
 
 gint
-on_var_type_cancel_clicked(GtkWidget *w,  gpointer data)
+on_var_type_cancel_clicked (GtkWidget *w,  gpointer data)
 {
-  gtk_widget_hide(w);
+  gtk_widget_hide (w);
 
   return FALSE;
 }
index a51eeaa5263e227ba171eb858000f86e12bfa8bb..eaad7b83856f3c9225ae9d247210075f6a9d2829 100644 (file)
@@ -88,13 +88,13 @@ struct var_type_dialog
 };
 
 
-struct var_type_dialog * var_type_dialog_create(GladeXML *xml);
+struct var_type_dialog * var_type_dialog_create (GladeXML *xml);
 
 
-void var_type_dialog_set_variable(struct var_type_dialog *dialog,
+void var_type_dialog_set_variable (struct var_type_dialog *dialog,
                                  variable_changed_func set_variable_changed,
                                  struct variable *var);
 
-void var_type_dialog_show(struct var_type_dialog *dialog);
+void var_type_dialog_show (struct var_type_dialog *dialog);
 
 #endif