src/ui/gui/descriptives-dialog.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2007  Free Software Foundation
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include "descriptives-dialog.h"
  20
  21 #include <gtk/gtk.h>
  22 #include <gtksheet/gtksheet.h>
  23 #include <stdlib.h>
  24
  25 #include <language/syntax-string-source.h>
  26 #include <ui/gui/data-editor.h>
  27 #include <ui/gui/dialog-common.h>
  28 #include <ui/gui/dict-display.h>
  29 #include <ui/gui/helper.h>
  30 #include <ui/gui/psppire-dialog.h>
  31 #include <ui/gui/psppire-var-store.h>
  32 #include <ui/gui/syntax-editor.h>
  33
  34 #include "gettext.h"
  35 #define _(msgid) gettext (msgid)
  36 #define N_(msgid) msgid
  37
  38 enum
  39   {
  40     COLUMN_LABEL,
  41     COLUMN_SELECTED,
  42     N_STAT_COLUMNS
  43   };
  44
  45 struct descriptive_stat
  46   {
  47     const char *name;
  48     const char *label;
  49   };
  50
  51 #define DESCRIPTIVE_STATS                       \
  52   DS (MEAN, N_("Mean"))                         \
  53   DS (STDDEV, N_("Standard deviation"))         \
  54   DS (MINIMUM, N_("Minimum"))                   \
  55   DS (MAXIMUM, N_("Maximum"))                   \
  56   DS (RANGE, N_("Range"))                       \
  57   DS (SUM, N_("Sum"))                           \
  58   DS (SEMEAN, N_("Standard error"))             \
  59   DS (VARIANCE, N_("Variance"))                 \
  60   DS (KURTOSIS, N_("Kurtosis"))                 \
  61   DS (SKEWNESS, N_("Skewness"))
  62
  63 enum
  64   {
  65 #define DS(NAME, LABEL) DS_##NAME,
  66     DESCRIPTIVE_STATS
  67 #undef DS
  68     N_DESCRIPTIVE_STATS
  69   };
  70
  71 enum
  72   {
  73 #define DS(NAME, LABEL) B_DS_##NAME = 1u << DS_##NAME,
  74     DESCRIPTIVE_STATS
  75 #undef DS
  76     B_DS_ALL = (1u << N_DESCRIPTIVE_STATS) - 1,
  77     B_DS_DEFAULT = B_DS_MEAN | B_DS_STDDEV | B_DS_MINIMUM | B_DS_MAXIMUM
  78   };
  79
  80 static const struct descriptive_stat stats[] =
  81   {
  82 #define DS(NAME, LABEL) {#NAME, LABEL},
  83     DESCRIPTIVE_STATS
  84 #undef DS
  85   };
  86
  87 struct descriptives_dialog
  88 {
  89   GtkTreeView *stat_vars;
  90   GtkTreeModel *stats;
  91   PsppireDict *dict;
  92   GtkToggleButton *exclude_missing_listwise;
  93   GtkToggleButton *include_user_missing;
  94   GtkToggleButton *save_z_scores;
  95 };
  96
  97 static void
  98 refresh (PsppireDialog *dialog, struct descriptives_dialog *scd)
  99 {
 100   GtkTreeModel *liststore;
 101   GtkTreeIter iter;
 102   size_t i;
 103   bool ok;
 104
 105   liststore = gtk_tree_view_get_model (scd->stat_vars);
 106   gtk_list_store_clear (GTK_LIST_STORE (liststore));
 107
 108   for (i = 0, ok = gtk_tree_model_get_iter_first (scd->stats, &iter); ok;
 109        i++, ok = gtk_tree_model_iter_next (scd->stats, &iter))
 110     gtk_list_store_set (GTK_LIST_STORE (scd->stats), &iter, COLUMN_SELECTED,
 111                         (B_DS_DEFAULT & (1u << i)) ? true : false, -1);
 112
 113   gtk_toggle_button_set_active (scd->exclude_missing_listwise, false);
 114   gtk_toggle_button_set_active (scd->include_user_missing, false);
 115   gtk_toggle_button_set_active (scd->save_z_scores, false);
 116 }
 117
 118 static char *
 119 generate_syntax (const struct descriptives_dialog *scd)
 120 {
 121   gchar *text;
 122   GString *string;
 123   GtkTreeIter iter;
 124   unsigned int selected;
 125   size_t i;
 126   bool listwise, include;
 127   bool ok;
 128
 129   string = g_string_new ("DESCRIPTIVES");
 130   g_string_append (string, "\n    /VARIABLES=");
 131   append_variable_names (string, scd->dict, GTK_TREE_VIEW (scd->stat_vars));
 132
 133   listwise = gtk_toggle_button_get_active (scd->exclude_missing_listwise);
 134   include = gtk_toggle_button_get_active (scd->include_user_missing);
 135   if (listwise || include)
 136     {
 137       g_string_append (string, "\n    /MISSING=");
 138       if (listwise)
 139         {
 140           g_string_append (string, "LISTWISE");
 141           if (include)
 142             g_string_append (string, " ");
 143         }
 144       if (include)
 145         g_string_append (string, "INCLUDE");
 146     }
 147
 148   selected = 0;
 149   for (i = 0, ok = gtk_tree_model_get_iter_first (scd->stats, &iter); ok;
 150        i++, ok = gtk_tree_model_iter_next (scd->stats, &iter))
 151     {
 152       gboolean toggled;
 153       gtk_tree_model_get (scd->stats, &iter, COLUMN_SELECTED, &toggled, -1);
 154       if (toggled)
 155         selected |= 1u << i;
 156     }
 157
 158   if (selected != B_DS_DEFAULT)
 159     {
 160       g_string_append (string, "\n    /STATISTICS=");
 161       if (selected == B_DS_ALL)
 162         g_string_append (string, "ALL");
 163       else if (selected == 0)
 164         g_string_append (string, "NONE");
 165       else
 166         {
 167           int n = 0;
 168           if ((selected & B_DS_DEFAULT) == B_DS_DEFAULT)
 169             {
 170               g_string_append (string, "DEFAULT");
 171               selected &= ~B_DS_DEFAULT;
 172               n++;
 173             }
 174           for (i = 0; i < N_DESCRIPTIVE_STATS; i++)
 175             if (selected & (1u << i))
 176               {
 177                 if (n++)
 178                   g_string_append (string, " ");
 179                 g_string_append (string, stats[i].name);
 180               }
 181         }
 182     }
 183
 184   if (gtk_toggle_button_get_active (scd->save_z_scores))
 185     g_string_append (string, "\n    /SAVE");
 186
 187   g_string_append (string, ".");
 188
 189   text = string->str;
 190
 191   g_string_free (string, FALSE);
 192
 193   return text;
 194 }
 195
 196 /* A GtkTreeCellDataFunc which renders a checkbox that determines
 197    whether to calculate the statistic. */
 198 static void
 199 stat_calculate_cell_data_func (GtkTreeViewColumn *col,
 200                                GtkCellRenderer *cell,
 201                                GtkTreeModel *model,
 202                                GtkTreeIter *iter,
 203                                gpointer data)
 204 {
 205   gboolean selected;
 206
 207   gtk_tree_model_get (model, iter, COLUMN_SELECTED, &selected, -1);
 208   g_object_set (cell, "active", selected, NULL);
 209 }
 210
 211 /* Callback for checkbox cells in the statistics tree view.
 212    Toggles the checkbox. */
 213 static void
 214 toggle (GtkCellRendererToggle *cell_renderer, gchar *path_str, gpointer data)
 215 {
 216   GtkTreeModel *model = (GtkTreeModel *)data;
 217   GtkTreeIter iter;
 218   GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
 219   gboolean selected;
 220
 221   gtk_tree_model_get_iter (model, &iter, path);
 222   gtk_tree_model_get (model, &iter, COLUMN_SELECTED, &selected, -1);
 223   gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_SELECTED,
 224                       !selected, -1);
 225   gtk_tree_path_free (path);
 226 }
 227
 228 /* A GtkTreeCellDataFunc which renders the label of the statistic. */
 229 static void
 230 stat_label_cell_data_func (GtkTreeViewColumn *col,
 231                            GtkCellRenderer *cell,
 232                            GtkTreeModel *model,
 233                            GtkTreeIter *iter,
 234                            gpointer statistic)
 235 {
 236   gchar *label = NULL;
 237   gtk_tree_model_get (model, iter, COLUMN_LABEL, &label, -1);
 238   g_object_set (cell, "text", gettext (label), NULL);
 239   g_free (label);
 240 }
 241
 242 static void
 243 put_statistics_in_treeview (GtkTreeView *treeview)
 244 {
 245   GtkTreeViewColumn *col;
 246   GtkCellRenderer *renderer;
 247   GtkListStore *list;
 248   size_t i;
 249
 250   list = gtk_list_store_new (N_STAT_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN);
 251   gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (list));
 252
 253   for (i = 0; i < sizeof stats / sizeof *stats; i++)
 254     {
 255       GtkTreeIter iter;
 256       gtk_list_store_append (list, &iter);
 257       gtk_list_store_set (list, &iter,
 258                           COLUMN_LABEL, stats[i].label,
 259                           COLUMN_SELECTED, (B_DS_DEFAULT & (1u << i)) != 0,
 260                           -1);
 261     }
 262
 263   /* Calculate column. */
 264   col = gtk_tree_view_column_new ();
 265   renderer = gtk_cell_renderer_toggle_new ();
 266   g_signal_connect (GTK_CELL_RENDERER_TOGGLE (renderer),
 267                     "toggled", G_CALLBACK (toggle), GTK_TREE_MODEL (list));
 268   gtk_tree_view_column_pack_start (col, renderer, TRUE);
 269   gtk_tree_view_column_set_cell_data_func (col, renderer,
 270                                            stat_calculate_cell_data_func,
 271                                            NULL, NULL);
 272   gtk_tree_view_append_column (treeview, col);
 273
 274   /* Statistic column. */
 275   col = gtk_tree_view_column_new ();
 276   gtk_tree_view_column_set_title (col, _("Statistic"));
 277   renderer = gtk_cell_renderer_text_new ();
 278   gtk_tree_view_column_pack_start (col, renderer, TRUE);
 279   gtk_tree_view_column_set_cell_data_func (col, renderer,
 280                                            stat_label_cell_data_func,
 281                                            NULL, NULL);
 282   g_object_set (renderer, "ellipsize-set", TRUE, NULL);
 283   g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 284   gtk_tree_view_column_set_min_width (col, 150);
 285   gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 286   gtk_tree_view_column_set_resizable (col, true);
 287   gtk_tree_view_append_column (treeview, col);
 288 }
 289
 290
 291 /* Dialog is valid iff at least one variable has been selected */
 292 static gboolean
 293 dialog_state_valid (gpointer data)
 294 {
 295   struct descriptives_dialog *dd = data;
 296
 297   GtkTreeModel *vars = gtk_tree_view_get_model (dd->stat_vars);
 298
 299   GtkTreeIter notused;
 300
 301   return gtk_tree_model_get_iter_first (vars, &notused);
 302 }
 303
 304 /* Pops up the Descriptives dialog box */
 305 void
 306 descriptives_dialog (GObject *o, gpointer data)
 307 {
 308   gint response;
 309   struct data_editor *de = data;
 310
 311   struct descriptives_dialog scd;
 312
 313   GladeXML *xml = XML_NEW ("descriptives-dialog.glade");
 314
 315   GtkWidget *dialog = get_widget_assert   (xml, "descriptives-dialog");
 316
 317
 318   GtkWidget *source = get_widget_assert   (xml, "all-variables");
 319   GtkWidget *selector = get_widget_assert (xml, "stat-var-selector");
 320   GtkWidget *dest =   get_widget_assert   (xml, "stat-variables");
 321
 322   GtkWidget *stats = get_widget_assert    (xml, "statistics");
 323
 324   GtkSheet *var_sheet =
 325     GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 326
 327   PsppireVarStore *vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 328
 329   gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
 330
 331   attach_dictionary_to_treeview (GTK_TREE_VIEW (source),
 332                                  vs->dict,
 333                                  GTK_SELECTION_MULTIPLE, var_is_numeric);
 334
 335   set_dest_model (GTK_TREE_VIEW (dest), vs->dict);
 336
 337   psppire_selector_set_subjects (PSPPIRE_SELECTOR (selector),
 338                                  source,
 339                                  dest,
 340                                  insert_source_row_into_tree_view,
 341                                  NULL);
 342
 343   put_statistics_in_treeview (GTK_TREE_VIEW (stats));
 344
 345   scd.stat_vars = GTK_TREE_VIEW (dest);
 346   scd.stats = gtk_tree_view_get_model (GTK_TREE_VIEW (stats));
 347   scd.dict = vs->dict;
 348   scd.include_user_missing =
 349     GTK_TOGGLE_BUTTON (get_widget_assert (xml, "include_user_missing"));
 350   scd.exclude_missing_listwise =
 351     GTK_TOGGLE_BUTTON (get_widget_assert (xml, "exclude_missing_listwise"));
 352   scd.save_z_scores =
 353     GTK_TOGGLE_BUTTON (get_widget_assert (xml, "save_z_scores"));
 354
 355   g_signal_connect (dialog, "refresh", G_CALLBACK (refresh),  &scd);
 356
 357   psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (dialog),
 358                                       dialog_state_valid, &scd);
 359
 360   response = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
 361
 362
 363   switch (response)
 364     {
 365     case GTK_RESPONSE_OK:
 366       {
 367         gchar *syntax = generate_syntax (&scd);
 368         struct getl_interface *sss = create_syntax_string_source (syntax);
 369         execute_syntax (sss);
 370
 371         g_free (syntax);
 372       }
 373       break;
 374     case PSPPIRE_RESPONSE_PASTE:
 375       {
 376         gchar *syntax = generate_syntax (&scd);
 377
 378         struct syntax_editor *se =
 379           (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
 380
 381         gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
 382
 383         g_free (syntax);
 384       }
 385       break;
 386     default:
 387       break;
 388     }
 389
 390   g_object_unref (xml);
 391 }