src/ui/gui/psppire-data-editor.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   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 #include <gtk/gtk.h>
  19 #include <gtk-contrib/gtkextra-sheet.h>
  20 #include "psppire-data-editor.h"
  21 #include "psppire-var-sheet.h"
  22
  23 #include "psppire-data-store.h"
  24 #include <libpspp/i18n.h>
  25 #include <ui/gui/sheet/psppire-axis.h>
  26 #include "executor.h"
  27
  28 #include <gtk-contrib/gtkxpaned.h>
  29 #include <gettext.h>
  30 #define _(msgid) gettext (msgid)
  31 #define N_(msgid) msgid
  32
  33
  34 static void psppire_data_editor_remove_split (PsppireDataEditor *de);
  35 static void psppire_data_editor_set_split (PsppireDataEditor *de);
  36
  37 enum {
  38   DATA_SELECTION_CHANGED,
  39   DATA_AVAILABLE_CHANGED,
  40   CASES_SELECTED,
  41   VARIABLES_SELECTED,
  42   n_SIGNALS
  43 };
  44
  45
  46 static guint data_editor_signals [n_SIGNALS] = { 0 };
  47
  48
  49 static gboolean data_is_selected (PsppireDataEditor *de);
  50
  51 static void psppire_data_editor_class_init          (PsppireDataEditorClass *klass);
  52 static void psppire_data_editor_init                (PsppireDataEditor      *de);
  53
  54 GType
  55 psppire_data_editor_get_type (void)
  56 {
  57   static GType de_type = 0;
  58
  59   if (!de_type)
  60     {
  61       static const GTypeInfo de_info =
  62       {
  63         sizeof (PsppireDataEditorClass),
  64         NULL, /* base_init */
  65         NULL, /* base_finalize */
  66         (GClassInitFunc) psppire_data_editor_class_init,
  67         NULL, /* class_finalize */
  68         NULL, /* class_data */
  69         sizeof (PsppireDataEditor),
  70         0,
  71         (GInstanceInitFunc) psppire_data_editor_init,
  72       };
  73
  74       de_type = g_type_register_static (GTK_TYPE_NOTEBOOK, "PsppireDataEditor",
  75                                         &de_info, 0);
  76     }
  77
  78   return de_type;
  79 }
  80
  81 static GObjectClass * parent_class = NULL;
  82
  83 static void
  84 psppire_data_editor_dispose (GObject *obj)
  85 {
  86   PsppireDataEditor *de = (PsppireDataEditor *) obj;
  87
  88   if (de->dispose_has_run)
  89     return;
  90
  91   g_object_unref (de->data_store);
  92   g_object_unref (de->var_store);
  93
  94   /* Make sure dispose does not run twice. */
  95   de->dispose_has_run = TRUE;
  96
  97   /* Chain up to the parent class */
  98   G_OBJECT_CLASS (parent_class)->dispose (obj);
  99 }
 100
 101 static void
 102 psppire_data_editor_finalize (GObject *obj)
 103 {
 104    /* Chain up to the parent class */
 105    G_OBJECT_CLASS (parent_class)->finalize (obj);
 106 }
 107
 108
 109
 110 static void popup_variable_column_menu (PsppireSheet *sheet, gint column,
 111                                         GdkEventButton *event, gpointer data);
 112
 113 static void popup_variable_row_menu (PsppireSheet *sheet, gint row,
 114                                      GdkEventButton *event, gpointer data);
 115
 116
 117 static void popup_cases_menu (PsppireSheet *sheet, gint row,
 118                               GdkEventButton *event, gpointer data);
 119
 120
 121
 122
 123
 124 /* Callback which occurs when the data sheet's column title
 125    is double clicked */
 126 static gboolean
 127 on_data_column_clicked (PsppireDataEditor *de, gint col, gpointer data)
 128 {
 129   PsppireSheetRange visible_range;
 130   gint current_row, current_column;
 131
 132   gtk_notebook_set_current_page (GTK_NOTEBOOK (de),
 133                                  PSPPIRE_DATA_EDITOR_VARIABLE_VIEW);
 134
 135   psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->var_sheet),
 136                              &current_row, &current_column);
 137
 138   psppire_sheet_set_active_cell (PSPPIRE_SHEET (de->var_sheet), col, current_column);
 139
 140
 141   psppire_sheet_get_visible_range (PSPPIRE_SHEET (de->var_sheet), &visible_range);
 142
 143   if ( col < visible_range.row0 || col > visible_range.rowi)
 144     psppire_sheet_moveto (PSPPIRE_SHEET (de->var_sheet), col, current_column, 0.5, 0.5);
 145
 146
 147   return FALSE;
 148 }
 149
 150
 151 /* Callback which occurs when the var sheet's row title
 152    button is double clicked */
 153 static gboolean
 154 on_var_row_clicked (PsppireDataEditor *de, gint row, gpointer data)
 155 {
 156   PsppireSheetRange visible_range;
 157
 158   gint current_row, current_column;
 159
 160   gtk_notebook_set_current_page (GTK_NOTEBOOK(de), PSPPIRE_DATA_EDITOR_DATA_VIEW);
 161
 162   psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]),
 163                              &current_row, &current_column);
 164
 165   psppire_sheet_set_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), current_row, row);
 166
 167   psppire_sheet_get_visible_range (PSPPIRE_SHEET (de->data_sheet[0]), &visible_range);
 168
 169   if ( row < visible_range.col0 || row > visible_range.coli)
 170     psppire_sheet_moveto (PSPPIRE_SHEET (de->data_sheet[0]), -1, row, 0.5, 0.5);
 171
 172   return FALSE;
 173 }
 174
 175
 176 /* Moves the focus to a new cell.
 177    Returns TRUE iff the move should be disallowed */
 178 static gboolean
 179 traverse_cell_callback (PsppireSheet *sheet,
 180                         PsppireSheetCell *existing_cell,
 181                         PsppireSheetCell *new_cell,
 182                         gpointer data)
 183 {
 184   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 185   const PsppireDict *dict = de->data_store->dict;
 186
 187   if ( new_cell->col >= psppire_dict_get_var_cnt (dict))
 188     return TRUE;
 189
 190   return FALSE;
 191 }
 192
 193
 194 enum
 195   {
 196     PROP_0,
 197     PROP_DATA_STORE,
 198     PROP_VAR_STORE,
 199     PROP_VS_ROW_MENU,
 200     PROP_DS_COLUMN_MENU,
 201     PROP_DS_ROW_MENU,
 202     PROP_VALUE_LABELS,
 203     PROP_CURRENT_CASE,
 204     PROP_CURRENT_VAR,
 205     PROP_DATA_SELECTED,
 206     PROP_SPLIT_WINDOW
 207   };
 208
 209
 210 #define DEFAULT_ROW_HEIGHT 25
 211
 212 static void
 213 new_data_callback (PsppireDataStore *ds, gpointer data)
 214 {
 215   gint i;
 216   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 217
 218   casenumber n_cases =  psppire_data_store_get_case_count (ds);
 219
 220   for (i = 0; i < 2; ++i)
 221     {
 222       psppire_axis_clear (de->vaxis[i]);
 223       psppire_axis_append_n (de->vaxis[i], n_cases, DEFAULT_ROW_HEIGHT);
 224     }
 225 }
 226
 227 static void
 228 case_inserted_callback (PsppireDataStore *ds, gint before, gpointer data)
 229 {
 230   gint i;
 231   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 232
 233   for (i = 0; i < 2; ++i)
 234     psppire_axis_insert (de->vaxis[i], before, DEFAULT_ROW_HEIGHT);
 235 }
 236
 237
 238 static void
 239 cases_deleted_callback (PsppireDataStore *ds, gint first, gint n_cases, gpointer data)
 240 {
 241   gint i;
 242   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 243
 244   for (i = 0; i < 2; ++i)
 245     psppire_axis_delete (de->vaxis[0], first, n_cases);
 246 }
 247
 248
 249
 250 /* Return the width (in pixels) of an upper case M when rendered in the
 251    current font of W
 252 */
 253 static gint
 254 width_of_m (GtkWidget *w)
 255 {
 256   PangoRectangle rect;
 257   PangoLayout *layout = gtk_widget_create_pango_layout (w, "M");
 258
 259   pango_layout_get_pixel_extents (layout, NULL, &rect);
 260
 261   g_object_unref (layout);
 262
 263   return rect.width;
 264 }
 265
 266 /* Callback for the axis' resize signal.
 267    Changes the variable's display width */
 268 static void
 269 rewidth_variable (GtkWidget *w, gint unit, glong size)
 270 {
 271   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (w);
 272
 273   const PsppireDict *dict = de->data_store->dict;
 274   struct variable *var = psppire_dict_get_variable (dict, unit);
 275
 276   if (NULL == var)
 277     return;
 278
 279   var_set_display_width (var, size / (float) width_of_m (w));
 280 }
 281
 282
 283 static void
 284 new_variables_callback (PsppireDict *dict, gpointer data)
 285 {
 286   gint v;
 287   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 288   gint m_width = width_of_m (GTK_WIDGET (de));
 289
 290   PsppireAxis *vaxis;
 291   g_object_get (de->var_sheet, "vertical-axis", &vaxis, NULL);
 292
 293   psppire_axis_clear (vaxis);
 294   psppire_axis_append_n (vaxis, 1 + psppire_dict_get_var_cnt (dict), DEFAULT_ROW_HEIGHT);
 295
 296   g_signal_connect_swapped (de->haxis, "resize-unit",
 297                             G_CALLBACK (rewidth_variable), de);
 298
 299   psppire_axis_clear (de->haxis);
 300
 301   for (v = 0 ; v < psppire_dict_get_var_cnt (dict); ++v)
 302     {
 303       const struct variable *var = psppire_dict_get_variable (dict, v);
 304
 305       psppire_axis_append (de->haxis, m_width * var_get_display_width (var));
 306     }
 307 }
 308
 309 static void
 310 insert_variable_callback (PsppireDict *dict, gint x, gpointer data)
 311 {
 312   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 313
 314   gint m_width  = width_of_m (GTK_WIDGET (de));
 315
 316   PsppireAxis *var_vaxis;
 317
 318   const struct variable *var = psppire_dict_get_variable (dict, x);
 319
 320   g_object_get (de->var_sheet, "vertical-axis", &var_vaxis, NULL);
 321
 322   psppire_axis_insert (var_vaxis, x, DEFAULT_ROW_HEIGHT);
 323
 324
 325   psppire_axis_insert (de->haxis, x, m_width * var_get_display_width (var));
 326 }
 327
 328
 329 static void
 330 delete_variable_callback (PsppireDict *dict, gint posn,
 331                           gint x UNUSED, gint y UNUSED, gpointer data)
 332 {
 333   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 334
 335   PsppireAxis *var_vaxis;
 336   g_object_get (de->var_sheet, "vertical-axis", &var_vaxis, NULL);
 337
 338   psppire_axis_delete (var_vaxis, posn, 1);
 339
 340   psppire_axis_delete (de->haxis, posn, 1);
 341 }
 342
 343
 344 static void
 345 rewidth_variable_callback (PsppireDict *dict, gint posn, gpointer data)
 346 {
 347   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
 348   gint m_width = width_of_m (GTK_WIDGET (de));
 349
 350   const struct variable *var = psppire_dict_get_variable (dict, posn);
 351
 352   gint var_width = var_get_display_width (var);
 353
 354   /* Don't allow zero width */
 355   if ( var_width < 1 )
 356     var_width = 1;
 357
 358   psppire_axis_resize (de->haxis, posn, m_width * var_width);
 359 }
 360
 361
 362 static void
 363 psppire_data_editor_set_property (GObject         *object,
 364                                   guint            prop_id,
 365                                   const GValue    *value,
 366                                   GParamSpec      *pspec)
 367 {
 368   int i;
 369   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (object);
 370
 371   switch (prop_id)
 372     {
 373     case PROP_SPLIT_WINDOW:
 374       psppire_data_editor_split_window (de, g_value_get_boolean (value));
 375       break;
 376     case PROP_DATA_STORE:
 377       if ( de->data_store) g_object_unref (de->data_store);
 378       de->data_store = g_value_get_pointer (value);
 379       g_object_ref (de->data_store);
 380
 381       for (i = 0 ; i < 4 ; ++i )
 382         {
 383           g_object_set (de->data_sheet[i],
 384                         "model", de->data_store,
 385                         NULL);
 386
 387           g_signal_connect_swapped (de->data_store->dict, "filter-changed",
 388                                     G_CALLBACK (gtk_widget_queue_draw),
 389                                     de->data_sheet[i]);
 390         }
 391
 392       g_signal_connect (de->data_store->dict, "backend-changed",
 393                         G_CALLBACK (new_variables_callback), de);
 394
 395       g_signal_connect (de->data_store->dict, "variable-inserted",
 396                         G_CALLBACK (insert_variable_callback), de);
 397
 398       g_signal_connect (de->data_store->dict, "variable-deleted",
 399                         G_CALLBACK (delete_variable_callback), de);
 400
 401       g_signal_connect (de->data_store->dict, "variable-display-width-changed",
 402                         G_CALLBACK (rewidth_variable_callback), de);
 403
 404       g_signal_connect (de->data_store, "backend-changed",
 405                         G_CALLBACK (new_data_callback), de);
 406
 407       g_signal_connect (de->data_store, "case-inserted",
 408                         G_CALLBACK (case_inserted_callback), de);
 409
 410       g_signal_connect (de->data_store, "cases-deleted",
 411                         G_CALLBACK (cases_deleted_callback), de);
 412
 413       break;
 414     case PROP_VAR_STORE:
 415       if ( de->var_store) g_object_unref (de->var_store);
 416       de->var_store = g_value_get_pointer (value);
 417       g_object_ref (de->var_store);
 418
 419       g_object_set (de->var_sheet,
 420                     "model", de->var_store,
 421                     NULL);
 422       break;
 423     case PROP_VS_ROW_MENU:
 424       {
 425         GObject *menu = g_value_get_object (value);
 426
 427         g_signal_connect (de->var_sheet, "button-event-row",
 428                           G_CALLBACK (popup_variable_row_menu), menu);
 429       }
 430       break;
 431     case PROP_DS_COLUMN_MENU:
 432       {
 433         GObject *menu = g_value_get_object (value);
 434
 435         g_signal_connect (de->data_sheet[0], "button-event-column",
 436                           G_CALLBACK (popup_variable_column_menu), menu);
 437       }
 438       break;
 439     case PROP_DS_ROW_MENU:
 440       {
 441         GObject *menu = g_value_get_object (value);
 442
 443         g_signal_connect (de->data_sheet[0], "button-event-row",
 444                           G_CALLBACK (popup_cases_menu), menu);
 445       }
 446       break;
 447     case PROP_CURRENT_VAR:
 448       {
 449         gint row, col;
 450         gint var = g_value_get_long (value);
 451         switch (gtk_notebook_get_current_page (GTK_NOTEBOOK (object)))
 452           {
 453           case PSPPIRE_DATA_EDITOR_DATA_VIEW:
 454             psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), &row, &col);
 455             psppire_sheet_set_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), row, var);
 456             psppire_sheet_moveto (PSPPIRE_SHEET (de->data_sheet[0]), -1, var, 0.5, 0.5);
 457             break;
 458           case PSPPIRE_DATA_EDITOR_VARIABLE_VIEW:
 459             psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->var_sheet), &row, &col);
 460             psppire_sheet_set_active_cell (PSPPIRE_SHEET (de->var_sheet), var, col);
 461             psppire_sheet_moveto (PSPPIRE_SHEET (de->var_sheet), var, -1,  0.5, 0.5);
 462             break;
 463           default:
 464             g_assert_not_reached ();
 465             break;
 466           };
 467       }
 468       break;
 469     case PROP_CURRENT_CASE:
 470       {
 471         gint row, col;
 472         gint case_num = g_value_get_long (value);
 473         psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), &row, &col);
 474         psppire_sheet_set_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), case_num, col);
 475         psppire_sheet_moveto (PSPPIRE_SHEET (de->data_sheet[0]), case_num, -1, 0.5, 0.5);
 476       }
 477       break;
 478     case PROP_VALUE_LABELS:
 479       {
 480         psppire_data_store_show_labels (de->data_store,
 481                                         g_value_get_boolean (value));
 482       }
 483       break;
 484     default:
 485       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 486       break;
 487     };
 488 }
 489
 490 static void
 491 psppire_data_editor_get_property (GObject         *object,
 492                                   guint            prop_id,
 493                                   GValue          *value,
 494                                   GParamSpec      *pspec)
 495 {
 496   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (object);
 497
 498   switch (prop_id)
 499     {
 500     case PROP_SPLIT_WINDOW:
 501       g_value_set_boolean (value, de->split);
 502       break;
 503     case PROP_DATA_STORE:
 504       g_value_set_pointer (value, de->data_store);
 505       break;
 506     case PROP_VAR_STORE:
 507       g_value_set_pointer (value, de->var_store);
 508       break;
 509     case PROP_CURRENT_CASE:
 510       {
 511         gint row, column;
 512         psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), &row, &column);
 513         g_value_set_long (value, row);
 514       }
 515       break;
 516     case PROP_CURRENT_VAR:
 517       {
 518         gint row, column;
 519         psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), &row, &column);
 520         g_value_set_long (value, column);
 521       }
 522       break;
 523     case PROP_DATA_SELECTED:
 524       g_value_set_boolean (value, data_is_selected (de));
 525       break;
 526     default:
 527       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 528       break;
 529     };
 530 }
 531
 532
 533 static void
 534 psppire_data_editor_class_init (PsppireDataEditorClass *klass)
 535 {
 536   GParamSpec *data_store_spec ;
 537   GParamSpec *var_store_spec ;
 538   GParamSpec *column_menu_spec;
 539   GParamSpec *ds_row_menu_spec;
 540   GParamSpec *vs_row_menu_spec;
 541   GParamSpec *value_labels_spec;
 542   GParamSpec *current_case_spec;
 543   GParamSpec *current_var_spec;
 544   GParamSpec *data_selected_spec;
 545   GParamSpec *split_window_spec;
 546   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 547
 548   parent_class = g_type_class_peek_parent (klass);
 549
 550   object_class->dispose = psppire_data_editor_dispose;
 551   object_class->finalize = psppire_data_editor_finalize;
 552
 553   object_class->set_property = psppire_data_editor_set_property;
 554   object_class->get_property = psppire_data_editor_get_property;
 555
 556
 557
 558   data_store_spec =
 559     g_param_spec_pointer ("data-store",
 560                           "Data Store",
 561                           "A pointer to the data store associated with this editor",
 562                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_READABLE );
 563
 564   g_object_class_install_property (object_class,
 565                                    PROP_DATA_STORE,
 566                                    data_store_spec);
 567
 568   var_store_spec =
 569     g_param_spec_pointer ("var-store",
 570                           "Variable Store",
 571                           "A pointer to the variable store associated with this editor",
 572                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_READABLE );
 573
 574   g_object_class_install_property (object_class,
 575                                    PROP_VAR_STORE,
 576                                    var_store_spec);
 577
 578   column_menu_spec =
 579     g_param_spec_object ("datasheet-column-menu",
 580                          "Data Sheet Column Menu",
 581                          "A menu to be displayed when button 3 is pressed in thedata sheet's column title buttons",
 582                          GTK_TYPE_MENU,
 583                          G_PARAM_WRITABLE);
 584
 585   g_object_class_install_property (object_class,
 586                                    PROP_DS_COLUMN_MENU,
 587                                    column_menu_spec);
 588
 589
 590   ds_row_menu_spec =
 591     g_param_spec_object ("datasheet-row-menu",
 592                          "Data Sheet Row Menu",
 593                          "A menu to be displayed when button 3 is pressed in the data sheet's row title buttons",
 594                          GTK_TYPE_MENU,
 595                          G_PARAM_WRITABLE);
 596
 597   g_object_class_install_property (object_class,
 598                                    PROP_DS_ROW_MENU,
 599                                    ds_row_menu_spec);
 600
 601
 602   vs_row_menu_spec =
 603     g_param_spec_object ("varsheet-row-menu",
 604                          "Variable Sheet Row Menu",
 605                          "A menu to be displayed when button 3 is pressed in the variable sheet's row title buttons",
 606                          GTK_TYPE_MENU,
 607                          G_PARAM_WRITABLE);
 608
 609   g_object_class_install_property (object_class,
 610                                    PROP_VS_ROW_MENU,
 611                                    vs_row_menu_spec);
 612
 613
 614   value_labels_spec =
 615     g_param_spec_boolean ("value-labels",
 616                          "Value Labels",
 617                          "Whether or not the data sheet should display labels instead of values",
 618                           FALSE,
 619                          G_PARAM_WRITABLE | G_PARAM_READABLE);
 620
 621   g_object_class_install_property (object_class,
 622                                    PROP_VALUE_LABELS,
 623                                    value_labels_spec);
 624
 625
 626   current_case_spec =
 627     g_param_spec_long ("current-case",
 628                        "Current Case",
 629                        "Zero based number of the selected case",
 630                        0, CASENUMBER_MAX,
 631                        0,
 632                        G_PARAM_WRITABLE | G_PARAM_READABLE);
 633
 634   g_object_class_install_property (object_class,
 635                                    PROP_CURRENT_CASE,
 636                                    current_case_spec);
 637
 638
 639   current_var_spec =
 640     g_param_spec_long ("current-variable",
 641                        "Current Variable",
 642                        "Zero based number of the selected variable",
 643                        0, G_MAXINT,
 644                        0,
 645                        G_PARAM_WRITABLE | G_PARAM_READABLE);
 646
 647   g_object_class_install_property (object_class,
 648                                    PROP_CURRENT_VAR,
 649                                    current_var_spec);
 650
 651
 652   data_selected_spec =
 653     g_param_spec_boolean ("data-selected",
 654                           "Data Selected",
 655                           "True iff the data view is active and  one or more cells of data have been selected.",
 656                           FALSE,
 657                           G_PARAM_READABLE);
 658
 659   g_object_class_install_property (object_class,
 660                                    PROP_DATA_SELECTED,
 661                                    data_selected_spec);
 662
 663
 664
 665   split_window_spec =
 666     g_param_spec_boolean ("split",
 667                           "Split Window",
 668                           "True iff the data sheet is split",
 669                           FALSE,
 670                           G_PARAM_READABLE | G_PARAM_WRITABLE);
 671
 672   g_object_class_install_property (object_class,
 673                                    PROP_SPLIT_WINDOW,
 674                                    split_window_spec);
 675
 676   data_editor_signals [DATA_SELECTION_CHANGED] =
 677     g_signal_new ("data-selection-changed",
 678                   G_TYPE_FROM_CLASS (klass),
 679                   G_SIGNAL_RUN_FIRST,
 680                   0,
 681                   NULL, NULL,
 682                   g_cclosure_marshal_VOID__BOOLEAN,
 683                   G_TYPE_NONE,
 684                   1,
 685                   G_TYPE_BOOLEAN);
 686
 687   data_editor_signals [CASES_SELECTED] =
 688     g_signal_new ("cases-selected",
 689                   G_TYPE_FROM_CLASS (klass),
 690                   G_SIGNAL_RUN_FIRST,
 691                   0,
 692                   NULL, NULL,
 693                   g_cclosure_marshal_VOID__INT,
 694                   G_TYPE_NONE,
 695                   1,
 696                   G_TYPE_INT);
 697
 698
 699   data_editor_signals [VARIABLES_SELECTED] =
 700     g_signal_new ("variables-selected",
 701                   G_TYPE_FROM_CLASS (klass),
 702                   G_SIGNAL_RUN_FIRST,
 703                   0,
 704                   NULL, NULL,
 705                   g_cclosure_marshal_VOID__INT,
 706                   G_TYPE_NONE,
 707                   1,
 708                   G_TYPE_INT);
 709
 710
 711   data_editor_signals [DATA_AVAILABLE_CHANGED] =
 712     g_signal_new ("data-available-changed",
 713                   G_TYPE_FROM_CLASS (klass),
 714                   G_SIGNAL_RUN_FIRST,
 715                   0,
 716                   NULL, NULL,
 717                   g_cclosure_marshal_VOID__BOOLEAN,
 718                   G_TYPE_NONE,
 719                   1,
 720                   G_TYPE_BOOLEAN);
 721 }
 722
 723 /* Update the data_ref_entry with the reference of the active cell */
 724 static gint
 725 update_data_ref_entry (const PsppireSheet *sheet,
 726                        gint row, gint col,
 727                        gint old_row, gint old_col,
 728                        gpointer data)
 729 {
 730   PsppireDataEditor *de = data;
 731
 732   PsppireDataStore *data_store =
 733     PSPPIRE_DATA_STORE (psppire_sheet_get_model (sheet));
 734
 735   if (data_store)
 736     {
 737       const struct variable *var =
 738         psppire_dict_get_variable (data_store->dict, col);
 739
 740       if ( var )
 741         {
 742           gchar *text = g_strdup_printf ("%d: %s", row + FIRST_CASE_NUMBER,
 743                                          var_get_name (var));
 744
 745
 746           gtk_entry_set_text (GTK_ENTRY (de->cell_ref_entry), text);
 747
 748           g_free (text);
 749         }
 750       else
 751         goto blank_entry;
 752
 753       if ( var )
 754         {
 755           gchar *text =
 756             psppire_data_store_get_string (data_store, row,
 757                                            var_get_dict_index(var));
 758
 759           if ( ! text )
 760             goto blank_entry;
 761
 762           g_strchug (text);
 763
 764           gtk_entry_set_text (GTK_ENTRY (de->datum_entry), text);
 765
 766           g_free (text);
 767         }
 768       else
 769         goto blank_entry;
 770
 771     }
 772
 773   return FALSE;
 774
 775  blank_entry:
 776   gtk_entry_set_text (GTK_ENTRY (de->datum_entry), "");
 777
 778   return FALSE;
 779 }
 780
 781
 782 static void
 783 datum_entry_activate (GtkEntry *entry, gpointer data)
 784 {
 785   gint row, column;
 786   PsppireDataEditor *de = data;
 787
 788   const gchar *text = gtk_entry_get_text (entry);
 789
 790   psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), &row, &column);
 791
 792   if ( row == -1 || column == -1)
 793     return;
 794
 795   psppire_data_store_set_string (de->data_store, text, row, column);
 796 }
 797
 798 static void on_activate (PsppireDataEditor *de);
 799 static gboolean on_switch_page (PsppireDataEditor *de, GtkNotebookPage *p, gint pagenum, gpointer data);
 800 static void on_select_range (PsppireDataEditor *de);
 801
 802 static void on_select_row (PsppireSheet *, gint, PsppireDataEditor *);
 803 static void on_select_variable (PsppireSheet *, gint, PsppireDataEditor *);
 804
 805
 806 static void on_owner_change (GtkClipboard *,
 807                              GdkEventOwnerChange *, gpointer);
 808
 809 static void
 810 on_map (GtkWidget *w)
 811 {
 812   GtkClipboard *clip = gtk_widget_get_clipboard (w, GDK_SELECTION_CLIPBOARD);
 813
 814   g_signal_connect (clip, "owner-change", G_CALLBACK (on_owner_change), w);
 815 }
 816
 817
 818 static void
 819 init_sheet (PsppireDataEditor *de, int i,
 820             GtkAdjustment *hadj, GtkAdjustment *vadj,
 821             PsppireAxis *vaxis,
 822             PsppireAxis *haxis
 823             )
 824 {
 825   de->sheet_bin[i] = gtk_scrolled_window_new (hadj, vadj);
 826
 827   de->data_sheet[i] = psppire_sheet_new (NULL);
 828
 829   g_object_set (de->sheet_bin[i],
 830                 "border-width", 3,
 831                 "shadow-type",  GTK_SHADOW_ETCHED_IN,
 832                 NULL);
 833
 834   g_object_set (haxis, "default-size", 75, NULL);
 835   g_object_set (vaxis, "default-size", 25, NULL);
 836
 837   g_object_set (de->data_sheet[i],
 838                 "horizontal-axis", haxis,
 839                 "vertical-axis", vaxis,
 840                 NULL);
 841
 842   gtk_container_add (GTK_CONTAINER (de->sheet_bin[i]), de->data_sheet[i]);
 843
 844   g_signal_connect (de->data_sheet[i], "traverse",
 845                     G_CALLBACK (traverse_cell_callback), de);
 846
 847   gtk_widget_show (de->sheet_bin[i]);
 848 }
 849
 850
 851 static void
 852 init_data_sheet (PsppireDataEditor *de)
 853 {
 854   GtkAdjustment *vadj0, *hadj0;
 855   GtkAdjustment *vadj1, *hadj1;
 856   GtkWidget *sheet ;
 857
 858   de->vaxis[0] = psppire_axis_new ();
 859   de->vaxis[1] = psppire_axis_new ();
 860
 861   /* There's only one horizontal axis, since the
 862      column widths are parameters of the variables */
 863   de->haxis = psppire_axis_new ();
 864
 865   de->split = TRUE;
 866   de->paned = gtk_xpaned_new ();
 867
 868   init_sheet (de, 0, NULL, NULL, de->vaxis[0], de->haxis);
 869   gtk_widget_show (de->sheet_bin[0]);
 870   vadj0 = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[0]));
 871   hadj0 = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[0]));
 872
 873   g_object_set (de->sheet_bin[0], "vscrollbar-policy", GTK_POLICY_NEVER, NULL);
 874   g_object_set (de->sheet_bin[0], "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
 875
 876   init_sheet (de, 1, NULL, vadj0, de->vaxis[0], de->haxis);
 877   gtk_widget_show (de->sheet_bin[1]);
 878   sheet = gtk_bin_get_child (GTK_BIN (de->sheet_bin[1]));
 879   psppire_sheet_hide_row_titles (PSPPIRE_SHEET (sheet));
 880   hadj1 = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[1]));
 881   g_object_set (de->sheet_bin[1], "vscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
 882   g_object_set (de->sheet_bin[1], "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
 883
 884   init_sheet (de, 2, hadj0, NULL, de->vaxis[1], de->haxis);
 885   gtk_widget_show (de->sheet_bin[2]);
 886   sheet = gtk_bin_get_child (GTK_BIN (de->sheet_bin[2]));
 887   psppire_sheet_hide_column_titles (PSPPIRE_SHEET (sheet));
 888   g_object_set (de->sheet_bin[2], "vscrollbar-policy", GTK_POLICY_NEVER, NULL);
 889   g_object_set (de->sheet_bin[2], "hscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
 890   vadj1 = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (de->sheet_bin[2]));
 891
 892   init_sheet (de, 3, hadj1, vadj1, de->vaxis[1], de->haxis);
 893   gtk_widget_show (de->sheet_bin[3]);
 894   sheet = gtk_bin_get_child (GTK_BIN (de->sheet_bin[3]));
 895   psppire_sheet_hide_column_titles (PSPPIRE_SHEET (sheet));
 896   psppire_sheet_hide_row_titles (PSPPIRE_SHEET (sheet));
 897   g_object_set (de->sheet_bin[3], "vscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
 898   g_object_set (de->sheet_bin[3], "hscrollbar-policy", GTK_POLICY_ALWAYS, NULL);
 899
 900   gtk_xpaned_pack_top_left (GTK_XPANED (de->paned), de->sheet_bin[0], TRUE, TRUE);
 901   gtk_xpaned_pack_top_right (GTK_XPANED (de->paned), de->sheet_bin[1], TRUE, TRUE);
 902   gtk_xpaned_pack_bottom_left (GTK_XPANED (de->paned), de->sheet_bin[2], TRUE, TRUE);
 903   gtk_xpaned_pack_bottom_right (GTK_XPANED (de->paned), de->sheet_bin[3], TRUE, TRUE);
 904
 905   gtk_xpaned_set_position_y (GTK_XPANED (de->paned), 150);
 906   gtk_xpaned_set_position_x (GTK_XPANED (de->paned), 350);
 907 }
 908
 909
 910 static void
 911 psppire_data_editor_init (PsppireDataEditor *de)
 912 {
 913   GtkWidget *hbox = gtk_hbox_new (FALSE, 0);
 914   GtkWidget *sw_vs = gtk_scrolled_window_new (NULL, NULL);
 915
 916   init_data_sheet (de);
 917
 918   de->data_vbox = gtk_vbox_new (FALSE, 0);
 919   de->var_sheet = psppire_var_sheet_new ();
 920
 921   g_object_set (de, "tab-pos", GTK_POS_BOTTOM, NULL);
 922
 923   de->datum_entry = gtk_entry_new ();
 924   de->cell_ref_entry = gtk_entry_new ();
 925
 926   g_object_set (de->cell_ref_entry,
 927                 "sensitive", FALSE,
 928                 "editable",  FALSE,
 929                 "width_chars", 25,
 930                 NULL);
 931
 932   gtk_box_pack_start (GTK_BOX (hbox), de->cell_ref_entry, FALSE, FALSE, 0);
 933   gtk_box_pack_start (GTK_BOX (hbox), de->datum_entry, TRUE, TRUE, 0);
 934
 935
 936   gtk_container_add (GTK_CONTAINER (sw_vs), de->var_sheet);
 937   gtk_widget_show_all (sw_vs);
 938
 939
 940   gtk_box_pack_start (GTK_BOX (de->data_vbox), hbox, FALSE, FALSE, 0);
 941   gtk_box_pack_start (GTK_BOX (de->data_vbox), de->paned, TRUE, TRUE, 0);
 942
 943
 944   psppire_data_editor_remove_split (de);
 945
 946   gtk_widget_show_all (de->data_vbox);
 947
 948   gtk_notebook_append_page (GTK_NOTEBOOK (de), de->data_vbox,
 949                             gtk_label_new_with_mnemonic (_("Data View")));
 950
 951   gtk_notebook_append_page (GTK_NOTEBOOK (de), sw_vs,
 952                             gtk_label_new_with_mnemonic (_("Variable View")));
 953
 954   g_signal_connect (de->data_sheet[0], "activate",
 955                     G_CALLBACK (update_data_ref_entry),
 956                     de);
 957
 958   g_signal_connect (de->datum_entry, "activate",
 959                     G_CALLBACK (datum_entry_activate),
 960                     de);
 961
 962
 963   g_signal_connect_swapped (de->data_sheet[0],
 964                     "double-click-column",
 965                     G_CALLBACK (on_data_column_clicked),
 966                     de);
 967
 968   g_signal_connect_swapped (de->var_sheet,
 969                     "double-click-row",
 970                     G_CALLBACK (on_var_row_clicked),
 971                     de);
 972
 973   g_signal_connect_swapped (de->data_sheet[0], "activate",
 974                             G_CALLBACK (on_activate),
 975                             de);
 976
 977   g_signal_connect_swapped (de->data_sheet[0], "select-range",
 978                             G_CALLBACK (on_select_range),
 979                             de);
 980
 981   g_signal_connect (de->data_sheet[0], "select-row",
 982                     G_CALLBACK (on_select_row), de);
 983
 984   g_signal_connect (de->data_sheet[0], "select-column",
 985                     G_CALLBACK (on_select_variable), de);
 986
 987
 988   g_signal_connect (de->var_sheet, "select-row",
 989                     G_CALLBACK (on_select_variable), de);
 990
 991
 992   g_signal_connect_after (de, "switch-page",
 993                     G_CALLBACK (on_switch_page),
 994                     NULL);
 995
 996   g_object_set (de, "can-focus", FALSE, NULL);
 997
 998   g_signal_connect (de, "map", G_CALLBACK (on_map), NULL);
 999
1000
1001   //     psppire_sheet_hide_column_titles (de->var_sheet);
1002   //  psppire_sheet_hide_row_titles (de->data_sheet);
1003
1004
1005   de->dispose_has_run = FALSE;
1006 }
1007
1008
1009 GtkWidget*
1010 psppire_data_editor_new (PsppireVarStore *var_store,
1011                          PsppireDataStore *data_store)
1012 {
1013   return  g_object_new (PSPPIRE_DATA_EDITOR_TYPE,
1014                                      "var-store",  var_store,
1015                                      "data-store",  data_store,
1016                                      NULL);
1017 }
1018
1019
1020 static void
1021 psppire_data_editor_remove_split (PsppireDataEditor *de)
1022 {
1023   if ( !de->split ) return;
1024   de->split = FALSE;
1025
1026   g_object_ref (de->sheet_bin[0]);
1027   gtk_container_remove (GTK_CONTAINER (de->paned), de->sheet_bin[0]);
1028
1029   g_object_ref (de->paned);
1030   gtk_container_remove (GTK_CONTAINER (de->data_vbox), de->paned);
1031
1032   gtk_box_pack_start (GTK_BOX (de->data_vbox), de->sheet_bin[0],
1033                       TRUE, TRUE, 0);
1034
1035   g_object_unref (de->sheet_bin[0]);
1036
1037   g_object_set (de->sheet_bin[0], "vscrollbar-policy",
1038                 GTK_POLICY_ALWAYS, NULL);
1039
1040   g_object_set (de->sheet_bin[0], "hscrollbar-policy",
1041                 GTK_POLICY_ALWAYS, NULL);
1042 }
1043
1044
1045 static void
1046 psppire_data_editor_set_split (PsppireDataEditor *de)
1047 {
1048   if ( de->split ) return;
1049   de->split = TRUE;
1050
1051   g_object_ref (de->sheet_bin[0]);
1052   gtk_container_remove (GTK_CONTAINER (de->data_vbox), de->sheet_bin[0]);
1053
1054   gtk_xpaned_pack_top_left (GTK_XPANED (de->paned), de->sheet_bin [0],
1055                             TRUE, TRUE);
1056
1057   gtk_box_pack_start (GTK_BOX (de->data_vbox), de->paned,
1058                       TRUE, TRUE, 0);
1059
1060   g_object_unref (de->paned);
1061
1062   g_object_set (de->sheet_bin[0], "vscrollbar-policy",
1063                 GTK_POLICY_NEVER, NULL);
1064
1065   g_object_set (de->sheet_bin[0], "hscrollbar-policy",
1066                 GTK_POLICY_NEVER, NULL);
1067 }
1068
1069 void
1070 psppire_data_editor_split_window (PsppireDataEditor *de, gboolean split)
1071 {
1072   if (split )
1073     psppire_data_editor_set_split (de);
1074   else
1075     psppire_data_editor_remove_split (de);
1076
1077   gtk_widget_show_all (de->data_vbox);
1078 }
1079
1080 static void data_sheet_set_clip (PsppireSheet *sheet);
1081 static void data_sheet_contents_received_callback (GtkClipboard *clipboard,
1082                                                    GtkSelectionData *sd,
1083                                                    gpointer data);
1084
1085
1086 void
1087 psppire_data_editor_clip_copy (PsppireDataEditor *de)
1088 {
1089   data_sheet_set_clip (PSPPIRE_SHEET (de->data_sheet[0]));
1090 }
1091
1092 void
1093 psppire_data_editor_clip_paste (PsppireDataEditor *de)
1094 {
1095   GdkDisplay *display = gtk_widget_get_display ( GTK_WIDGET (de));
1096   GtkClipboard *clipboard =
1097     gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD);
1098
1099   gtk_clipboard_request_contents (clipboard,
1100                                   gdk_atom_intern ("UTF8_STRING", TRUE),
1101                                   data_sheet_contents_received_callback,
1102                                   de);
1103 }
1104
1105
1106
1107 void
1108 psppire_data_editor_clip_cut (PsppireDataEditor *de)
1109 {
1110   gint max_rows, max_columns;
1111   gint r;
1112   PsppireSheetRange range;
1113   PsppireDataStore *ds = de->data_store;
1114
1115   data_sheet_set_clip (PSPPIRE_SHEET (de->data_sheet[0]));
1116
1117   /* Now blank all the cells */
1118   psppire_sheet_get_selected_range (PSPPIRE_SHEET (de->data_sheet[0]), &range);
1119
1120    /* If nothing selected, then use active cell */
1121   if ( range.row0 < 0 || range.col0 < 0 )
1122     {
1123       gint row, col;
1124       psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), &row, &col);
1125
1126       range.row0 = range.rowi = row;
1127       range.col0 = range.coli = col;
1128     }
1129
1130   /* The sheet range can include cells that do not include data.
1131      Exclude them from the range. */
1132   max_rows = psppire_data_store_get_case_count (ds);
1133   if (range.rowi >= max_rows)
1134     {
1135       if (max_rows == 0)
1136         return;
1137       range.rowi = max_rows - 1;
1138     }
1139
1140   max_columns = dict_get_var_cnt (ds->dict->dict);
1141   if (range.coli >= max_columns)
1142     {
1143       if (max_columns == 0)
1144         return;
1145       range.coli = max_columns - 1;
1146     }
1147
1148   g_return_if_fail (range.rowi >= range.row0);
1149   g_return_if_fail (range.row0 >= 0);
1150   g_return_if_fail (range.coli >= range.col0);
1151   g_return_if_fail (range.col0 >= 0);
1152
1153
1154   for (r = range.row0; r <= range.rowi ; ++r )
1155     {
1156       gint c;
1157
1158       for (c = range.col0 ; c <= range.coli; ++c)
1159         {
1160           psppire_data_store_set_string (ds, "", r, c);
1161         }
1162     }
1163
1164   /* and remove the selection */
1165   psppire_sheet_unselect_range (PSPPIRE_SHEET (de->data_sheet[0]));
1166 }
1167
1168
1169 \f
1170
1171 /* Popup menu related stuff */
1172
1173 static void
1174 popup_variable_column_menu (PsppireSheet *sheet, gint column,
1175                      GdkEventButton *event, gpointer data)
1176 {
1177   GtkMenu *menu = GTK_MENU (data);
1178
1179   PsppireDataStore *data_store =
1180     PSPPIRE_DATA_STORE (psppire_sheet_get_model (sheet));
1181
1182   const struct variable *v =
1183     psppire_dict_get_variable (data_store->dict, column);
1184
1185   if ( v && event->button == 3)
1186     {
1187       psppire_sheet_select_column (sheet, column);
1188
1189       gtk_menu_popup (menu,
1190                       NULL, NULL, NULL, NULL,
1191                       event->button, event->time);
1192     }
1193 }
1194
1195
1196 static void
1197 popup_variable_row_menu (PsppireSheet *sheet, gint row,
1198                      GdkEventButton *event, gpointer data)
1199 {
1200   GtkMenu *menu = GTK_MENU (data);
1201
1202   PsppireVarStore *var_store =
1203     PSPPIRE_VAR_STORE (psppire_sheet_get_model (sheet));
1204
1205   PsppireDict *dict;
1206   const struct variable *v ;
1207
1208   g_object_get (var_store, "dictionary", &dict, NULL);
1209
1210   v = psppire_dict_get_variable (dict, row);
1211
1212   if ( v && event->button == 3)
1213     {
1214       psppire_sheet_select_row (sheet, row);
1215
1216       gtk_menu_popup (menu,
1217                       NULL, NULL, NULL, NULL,
1218                       event->button, event->time);
1219     }
1220 }
1221
1222
1223 static void
1224 popup_cases_menu (PsppireSheet *sheet, gint row,
1225                   GdkEventButton *event, gpointer data)
1226 {
1227   GtkMenu *menu = GTK_MENU (data);
1228
1229   PsppireDataStore *data_store =
1230     PSPPIRE_DATA_STORE (psppire_sheet_get_model (sheet));
1231
1232   if ( row <= psppire_data_store_get_case_count (data_store) &&
1233        event->button == 3)
1234     {
1235       psppire_sheet_select_row (sheet, row);
1236
1237       gtk_menu_popup (menu,
1238                       NULL, NULL, NULL, NULL,
1239                       event->button, event->time);
1240     }
1241 }
1242
1243 \f
1244
1245 /* Sorting */
1246
1247 static void
1248 do_sort (PsppireDataStore *ds, int var, gboolean descend)
1249 {
1250   const struct variable *v =
1251     psppire_dict_get_variable (ds->dict, var);
1252   gchar *syntax;
1253
1254   syntax = g_strdup_printf ("SORT CASES BY %s%s.",
1255                             var_get_name (v), descend ? " (D)" : "");
1256   g_free (execute_syntax_string (syntax));
1257 }
1258
1259
1260 /* Sort the data by the the variable which the editor has currently
1261    selected */
1262 void
1263 psppire_data_editor_sort_ascending  (PsppireDataEditor *de)
1264 {
1265   PsppireSheetRange range;
1266   psppire_sheet_get_selected_range (PSPPIRE_SHEET(de->data_sheet[0]), &range);
1267
1268   do_sort (de->data_store,  range.col0, FALSE);
1269 }
1270
1271
1272 /* Sort the data by the the variable which the editor has currently
1273    selected */
1274 void
1275 psppire_data_editor_sort_descending (PsppireDataEditor *de)
1276 {
1277   PsppireSheetRange range;
1278   psppire_sheet_get_selected_range (PSPPIRE_SHEET(de->data_sheet[0]), &range);
1279
1280   do_sort (de->data_store,  range.col0, TRUE);
1281 }
1282
1283
1284 \f
1285
1286
1287 /* Insert a new variable  before the currently selected position */
1288 void
1289 psppire_data_editor_insert_variable (PsppireDataEditor *de)
1290 {
1291   glong posn = 0;
1292
1293   switch (gtk_notebook_get_current_page (GTK_NOTEBOOK (de)))
1294     {
1295     case PSPPIRE_DATA_EDITOR_DATA_VIEW:
1296       if ( PSPPIRE_SHEET (de->data_sheet[0])->select_status
1297            == PSPPIRE_SHEET_COLUMN_SELECTED )
1298         posn = PSPPIRE_SHEET (de->data_sheet[0])->range.col0;
1299       else
1300         posn = PSPPIRE_SHEET (de->data_sheet[0])->active_cell.col;
1301       break;
1302     case PSPPIRE_DATA_EDITOR_VARIABLE_VIEW:
1303       if ( PSPPIRE_SHEET (de->var_sheet)->select_status
1304            == PSPPIRE_SHEET_ROW_SELECTED )
1305         posn = PSPPIRE_SHEET (de->var_sheet)->range.row0;
1306       else
1307         posn = PSPPIRE_SHEET (de->var_sheet)->active_cell.row;
1308       break;
1309     default:
1310       g_assert_not_reached ();
1311       break;
1312     };
1313
1314   psppire_dict_insert_variable (de->data_store->dict, posn, NULL);
1315 }
1316
1317 /* Insert a new case before the currently selected position */
1318 void
1319 psppire_data_editor_insert_case (PsppireDataEditor *de)
1320 {
1321   glong posn = -1;
1322
1323   if ( PSPPIRE_SHEET (de->data_sheet[0])->select_status == PSPPIRE_SHEET_ROW_SELECTED )
1324     {
1325       posn = PSPPIRE_SHEET (de->data_sheet[0])->range.row0;
1326     }
1327   else
1328     {
1329       posn = PSPPIRE_SHEET (de->data_sheet[0])->active_cell.row;
1330     }
1331
1332   if ( posn == -1 ) posn = 0;
1333
1334   psppire_data_store_insert_new_case (de->data_store, posn);
1335 }
1336
1337 /* Delete the cases currently selected in the data sheet */
1338 void
1339 psppire_data_editor_delete_cases    (PsppireDataEditor *de)
1340 {
1341   gint first = PSPPIRE_SHEET (de->data_sheet[0])->range.row0;
1342   gint n = PSPPIRE_SHEET (de->data_sheet[0])->range.rowi - first + 1;
1343
1344   psppire_data_store_delete_cases (de->data_store, first, n);
1345
1346   psppire_sheet_unselect_range (PSPPIRE_SHEET (de->data_sheet[0]));
1347 }
1348
1349 /* Delete the variables currently selected in the
1350    datasheet or variable sheet */
1351 void
1352 psppire_data_editor_delete_variables (PsppireDataEditor *de)
1353 {
1354   PsppireDict *dict = NULL;
1355   gint first, n;
1356
1357   switch (gtk_notebook_get_current_page (GTK_NOTEBOOK (de)))
1358     {
1359     case PSPPIRE_DATA_EDITOR_DATA_VIEW:
1360       first = PSPPIRE_SHEET (de->data_sheet[0])->range.col0;
1361       n = PSPPIRE_SHEET (de->data_sheet[0])->range.coli - first + 1;
1362       break;
1363     case PSPPIRE_DATA_EDITOR_VARIABLE_VIEW:
1364       first = PSPPIRE_SHEET (de->var_sheet)->range.row0;
1365       n = PSPPIRE_SHEET (de->var_sheet)->range.rowi - first + 1;
1366       break;
1367     default:
1368       g_assert_not_reached ();
1369       break;
1370     }
1371
1372   g_object_get (de->var_store, "dictionary", &dict, NULL);
1373
1374   psppire_dict_delete_variables (dict, first, n);
1375
1376   psppire_sheet_unselect_range (PSPPIRE_SHEET (de->data_sheet[0]));
1377   psppire_sheet_unselect_range (PSPPIRE_SHEET (de->var_sheet));
1378 }
1379
1380
1381 void
1382 psppire_data_editor_show_grid (PsppireDataEditor *de, gboolean grid_visible)
1383 {
1384   psppire_sheet_show_grid (PSPPIRE_SHEET (de->var_sheet), grid_visible);
1385   psppire_sheet_show_grid (PSPPIRE_SHEET (de->data_sheet[0]), grid_visible);
1386 }
1387
1388
1389 static void
1390 set_font (GtkWidget *w, gpointer data)
1391 {
1392   PangoFontDescription *font_desc = data;
1393   GtkRcStyle *style = gtk_widget_get_modifier_style (w);
1394
1395   pango_font_description_free (style->font_desc);
1396   style->font_desc = pango_font_description_copy (font_desc);
1397
1398   gtk_widget_modify_style (w, style);
1399
1400   if ( GTK_IS_CONTAINER (w))
1401     gtk_container_foreach (GTK_CONTAINER (w), set_font, font_desc);
1402 }
1403
1404 void
1405 psppire_data_editor_set_font (PsppireDataEditor *de, PangoFontDescription *font_desc)
1406 {
1407   set_font (GTK_WIDGET (de), font_desc);
1408   gtk_container_foreach (GTK_CONTAINER (de), set_font, font_desc);
1409 }
1410
1411
1412 \f
1413
1414
1415 static void
1416 emit_selected_signal (PsppireDataEditor *de)
1417 {
1418   gboolean data_selected = data_is_selected (de);
1419
1420   g_signal_emit (de, data_editor_signals[DATA_SELECTION_CHANGED], 0, data_selected);
1421 }
1422
1423
1424 static void
1425 on_activate (PsppireDataEditor *de)
1426 {
1427   gint row, col;
1428   psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), &row, &col);
1429
1430
1431   if ( row < psppire_data_store_get_case_count (de->data_store)
1432        &&
1433        col < psppire_var_store_get_var_cnt (de->var_store))
1434     {
1435       emit_selected_signal (de);
1436       return ;
1437     }
1438
1439   emit_selected_signal (de);
1440 }
1441
1442
1443 static void
1444 on_select_range (PsppireDataEditor *de)
1445 {
1446   PsppireSheetRange range;
1447
1448   psppire_sheet_get_selected_range (PSPPIRE_SHEET (de->data_sheet[0]), &range);
1449
1450   if ( range.rowi < psppire_data_store_get_case_count (de->data_store)
1451        &&
1452        range.coli < psppire_var_store_get_var_cnt (de->var_store))
1453     {
1454       emit_selected_signal (de);
1455       return;
1456     }
1457
1458   emit_selected_signal (de);
1459 }
1460
1461
1462 static gboolean
1463 on_switch_page (PsppireDataEditor *de, GtkNotebookPage *p,
1464                 gint pagenum, gpointer data)
1465 {
1466   switch (pagenum)
1467     {
1468     case PSPPIRE_DATA_EDITOR_DATA_VIEW:
1469       gtk_widget_grab_focus (de->data_vbox);
1470       on_select_range (de);
1471       break;
1472     case PSPPIRE_DATA_EDITOR_VARIABLE_VIEW:
1473       gtk_widget_grab_focus (de->var_sheet);
1474       emit_selected_signal (de);
1475       break;
1476     default:
1477       break;
1478     };
1479
1480   return TRUE;
1481 }
1482
1483
1484
1485 static gboolean
1486 data_is_selected (PsppireDataEditor *de)
1487 {
1488   PsppireSheetRange range;
1489   gint row, col;
1490
1491   if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (de)) != PSPPIRE_DATA_EDITOR_DATA_VIEW)
1492     return FALSE;
1493
1494   psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), &row, &col);
1495
1496   if ( row >= psppire_data_store_get_case_count (de->data_store)
1497        ||
1498        col >= psppire_var_store_get_var_cnt (de->var_store))
1499     {
1500       return FALSE;
1501     }
1502
1503   psppire_sheet_get_selected_range (PSPPIRE_SHEET (de->data_sheet[0]), &range);
1504
1505   if ( range.rowi >= psppire_data_store_get_case_count (de->data_store)
1506        ||
1507        range.coli >= psppire_var_store_get_var_cnt (de->var_store))
1508     {
1509       return FALSE;
1510     }
1511
1512   return TRUE;
1513 }
1514
1515
1516 static void
1517 on_select_row (PsppireSheet *sheet, gint row, PsppireDataEditor *de)
1518 {
1519   g_signal_emit (de, data_editor_signals[CASES_SELECTED], 0, row);
1520 }
1521
1522
1523 static void
1524 on_select_variable (PsppireSheet *sheet, gint var, PsppireDataEditor *de)
1525 {
1526   g_signal_emit (de, data_editor_signals[VARIABLES_SELECTED], 0, var);
1527 }
1528
1529
1530 \f
1531
1532 /* Clipboard stuff */
1533
1534
1535 #include <data/casereader.h>
1536 #include <data/case-map.h>
1537 #include <data/casewriter.h>
1538
1539 #include <data/data-out.h>
1540 #include "xalloc.h"
1541
1542 /* A casereader and dictionary holding the data currently in the clip */
1543 static struct casereader *clip_datasheet = NULL;
1544 static struct dictionary *clip_dict = NULL;
1545
1546
1547 static void data_sheet_update_clipboard (PsppireSheet *);
1548
1549 /* Set the clip according to the currently
1550    selected range in the data sheet */
1551 static void
1552 data_sheet_set_clip (PsppireSheet *sheet)
1553 {
1554   int i;
1555   struct casewriter *writer ;
1556   PsppireSheetRange range;
1557   PsppireDataStore *ds;
1558   struct case_map *map = NULL;
1559   casenumber max_rows;
1560   size_t max_columns;
1561   gint row0, rowi;
1562   gint col0, coli;
1563
1564   ds = PSPPIRE_DATA_STORE (psppire_sheet_get_model (sheet));
1565
1566   psppire_sheet_get_selected_range (sheet, &range);
1567
1568   col0 = MIN (range.col0, range.coli);
1569   coli = MAX (range.col0, range.coli);
1570   row0 = MIN (range.row0, range.rowi);
1571   rowi = MAX (range.row0, range.rowi);
1572
1573    /* If nothing selected, then use active cell */
1574   if ( row0 < 0 || col0 < 0 )
1575     {
1576       gint row, col;
1577       psppire_sheet_get_active_cell (sheet, &row, &col);
1578
1579       row0 = rowi = row;
1580       col0 = coli = col;
1581     }
1582
1583   /* The sheet range can include cells that do not include data.
1584      Exclude them from the range. */
1585   max_rows = psppire_data_store_get_case_count (ds);
1586   if (rowi >= max_rows)
1587     {
1588       if (max_rows == 0)
1589         return;
1590       rowi = max_rows - 1;
1591     }
1592   max_columns = dict_get_var_cnt (ds->dict->dict);
1593   if (coli >= max_columns)
1594     {
1595       if (max_columns == 0)
1596         return;
1597       coli = max_columns - 1;
1598     }
1599
1600   /* Destroy any existing clip */
1601   if ( clip_datasheet )
1602     {
1603       casereader_destroy (clip_datasheet);
1604       clip_datasheet = NULL;
1605     }
1606
1607   if ( clip_dict )
1608     {
1609       dict_destroy (clip_dict);
1610       clip_dict = NULL;
1611     }
1612
1613   /* Construct clip dictionary. */
1614   clip_dict = dict_create (dict_get_encoding (ds->dict->dict));
1615   for (i = col0; i <= coli; i++)
1616     dict_clone_var_assert (clip_dict, dict_get_var (ds->dict->dict, i));
1617
1618   /* Construct clip data. */
1619   map = case_map_by_name (ds->dict->dict, clip_dict);
1620   writer = autopaging_writer_create (dict_get_proto (clip_dict));
1621   for (i = row0; i <= rowi ; ++i )
1622     {
1623       struct ccase *old = psppire_data_store_get_case (ds, i);
1624       if (old != NULL)
1625         casewriter_write (writer, case_map_execute (map, old));
1626       else
1627         casewriter_force_error (writer);
1628     }
1629   case_map_destroy (map);
1630
1631   clip_datasheet = casewriter_make_reader (writer);
1632
1633   data_sheet_update_clipboard (sheet);
1634 }
1635
1636 enum {
1637   SELECT_FMT_NULL,
1638   SELECT_FMT_TEXT,
1639   SELECT_FMT_HTML
1640 };
1641
1642
1643 /* Perform data_out for case CC, variable V, appending to STRING */
1644 static void
1645 data_out_g_string (GString *string, const struct variable *v,
1646                    const struct ccase *cc)
1647 {
1648   const struct fmt_spec *fs = var_get_print_format (v);
1649   const union value *val = case_data (cc, v);
1650
1651   char *s = data_out (val, var_get_encoding (v), fs);
1652
1653   g_string_append (string, s);
1654
1655   g_free (s);
1656 }
1657
1658 static GString *
1659 clip_to_text (void)
1660 {
1661   casenumber r;
1662   GString *string;
1663
1664   const size_t val_cnt = caseproto_get_n_widths (casereader_get_proto (clip_datasheet));
1665   const casenumber case_cnt = casereader_get_case_cnt (clip_datasheet);
1666   const size_t var_cnt = dict_get_var_cnt (clip_dict);
1667
1668   string = g_string_sized_new (10 * val_cnt * case_cnt);
1669
1670   for (r = 0 ; r < case_cnt ; ++r )
1671     {
1672       int c;
1673       struct ccase *cc;
1674
1675       cc = casereader_peek (clip_datasheet, r);
1676       if (cc == NULL)
1677         {
1678           g_warning ("Clipboard seems to have inexplicably shrunk");
1679           break;
1680         }
1681
1682       for (c = 0 ; c < var_cnt ; ++c)
1683         {
1684           const struct variable *v = dict_get_var (clip_dict, c);
1685           data_out_g_string (string, v, cc);
1686           if ( c < val_cnt - 1 )
1687             g_string_append (string, "\t");
1688         }
1689
1690       if ( r < case_cnt)
1691         g_string_append (string, "\n");
1692
1693       case_unref (cc);
1694     }
1695
1696   return string;
1697 }
1698
1699
1700 static GString *
1701 clip_to_html (void)
1702 {
1703   casenumber r;
1704   GString *string;
1705
1706   const size_t val_cnt = caseproto_get_n_widths (casereader_get_proto (clip_datasheet));
1707   const casenumber case_cnt = casereader_get_case_cnt (clip_datasheet);
1708   const size_t var_cnt = dict_get_var_cnt (clip_dict);
1709
1710   /* Guestimate the size needed */
1711   string = g_string_sized_new (80 + 20 * val_cnt * case_cnt);
1712
1713   g_string_append (string,
1714                    "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\n");
1715
1716   g_string_append (string, "<table>\n");
1717   for (r = 0 ; r < case_cnt ; ++r )
1718     {
1719       int c;
1720       struct ccase *cc = casereader_peek (clip_datasheet, r);
1721       if (cc == NULL)
1722         {
1723           g_warning ("Clipboard seems to have inexplicably shrunk");
1724           break;
1725         }
1726       g_string_append (string, "<tr>\n");
1727
1728       for (c = 0 ; c < var_cnt ; ++c)
1729         {
1730           const struct variable *v = dict_get_var (clip_dict, c);
1731           g_string_append (string, "<td>");
1732           data_out_g_string (string, v, cc);
1733           g_string_append (string, "</td>\n");
1734         }
1735
1736       g_string_append (string, "</tr>\n");
1737
1738       case_unref (cc);
1739     }
1740   g_string_append (string, "</table>\n");
1741
1742   return string;
1743 }
1744
1745
1746
1747 static void
1748 clipboard_get_cb (GtkClipboard     *clipboard,
1749                   GtkSelectionData *selection_data,
1750                   guint             info,
1751                   gpointer          data)
1752 {
1753   GString *string = NULL;
1754
1755   switch (info)
1756     {
1757     case SELECT_FMT_TEXT:
1758       string = clip_to_text ();
1759       break;
1760     case SELECT_FMT_HTML:
1761       string = clip_to_html ();
1762       break;
1763     default:
1764       g_assert_not_reached ();
1765     }
1766
1767   gtk_selection_data_set (selection_data, selection_data->target,
1768                           8,
1769                           (const guchar *) string->str, string->len);
1770
1771   g_string_free (string, TRUE);
1772 }
1773
1774 static void
1775 clipboard_clear_cb (GtkClipboard *clipboard,
1776                     gpointer data)
1777 {
1778   dict_destroy (clip_dict);
1779   clip_dict = NULL;
1780
1781   casereader_destroy (clip_datasheet);
1782   clip_datasheet = NULL;
1783 }
1784
1785
1786 static const GtkTargetEntry targets[] = {
1787   { "UTF8_STRING",   0, SELECT_FMT_TEXT },
1788   { "STRING",        0, SELECT_FMT_TEXT },
1789   { "TEXT",          0, SELECT_FMT_TEXT },
1790   { "COMPOUND_TEXT", 0, SELECT_FMT_TEXT },
1791   { "text/plain;charset=utf-8", 0, SELECT_FMT_TEXT },
1792   { "text/plain",    0, SELECT_FMT_TEXT },
1793   { "text/html",     0, SELECT_FMT_HTML }
1794 };
1795
1796
1797
1798 static void
1799 data_sheet_update_clipboard (PsppireSheet *sheet)
1800 {
1801   GtkClipboard *clipboard =
1802     gtk_widget_get_clipboard (GTK_WIDGET (sheet),
1803                               GDK_SELECTION_CLIPBOARD);
1804
1805   if (!gtk_clipboard_set_with_owner (clipboard, targets,
1806                                      G_N_ELEMENTS (targets),
1807                                      clipboard_get_cb, clipboard_clear_cb,
1808                                      G_OBJECT (sheet)))
1809     clipboard_clear_cb (clipboard, sheet);
1810 }
1811
1812
1813
1814 /* A callback for when the clipboard contents have been received */
1815 static void
1816 data_sheet_contents_received_callback (GtkClipboard *clipboard,
1817                                       GtkSelectionData *sd,
1818                                       gpointer data)
1819 {
1820   gint count = 0;
1821   gint row, column;
1822   gint next_row, next_column;
1823   gint first_column;
1824   char *c;
1825   PsppireDataEditor *data_editor = data;
1826
1827   if ( sd->length < 0 )
1828     return;
1829
1830   if ( sd->type != gdk_atom_intern ("UTF8_STRING", FALSE))
1831     return;
1832
1833   c = (char *) sd->data;
1834
1835   /* Paste text to selected position */
1836   psppire_sheet_get_active_cell (PSPPIRE_SHEET (data_editor->data_sheet[0]),
1837                              &row, &column);
1838
1839   g_return_if_fail (row >= 0);
1840   g_return_if_fail (column >= 0);
1841
1842   first_column = column;
1843   next_row = row;
1844   next_column = column;
1845   while (count < sd->length)
1846     {
1847       char *s = c;
1848
1849       row = next_row;
1850       column = next_column;
1851       while (*c != '\t' && *c != '\n' && count < sd->length)
1852         {
1853           c++;
1854           count++;
1855         }
1856       if ( *c == '\t')
1857         {
1858           next_row = row ;
1859           next_column = column + 1;
1860         }
1861       else if ( *c == '\n')
1862         {
1863           next_row = row + 1;
1864           next_column = first_column;
1865         }
1866       *c++ = '\0';
1867       count++;
1868
1869
1870       /* Append some new cases if pasting beyond the last row */
1871       if ( row >= psppire_data_store_get_case_count (data_editor->data_store))
1872         psppire_data_store_insert_new_case (data_editor->data_store, row);
1873
1874       psppire_data_store_set_string (data_editor->data_store, s, row, column);
1875     }
1876 }
1877
1878
1879 static void
1880 on_owner_change (GtkClipboard *clip, GdkEventOwnerChange *event, gpointer data)
1881 {
1882   gint i;
1883   gboolean compatible_target = FALSE;
1884   PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (data);
1885
1886   for (i = 0 ; i < sizeof (targets) / sizeof(targets[0]) ; ++i )
1887     {
1888       GdkAtom atom = gdk_atom_intern (targets[i].target, TRUE);
1889       if ( gtk_clipboard_wait_is_target_available (clip, atom))
1890         {
1891           compatible_target = TRUE;
1892           break;
1893         }
1894     }
1895
1896   g_signal_emit (de, data_editor_signals[DATA_AVAILABLE_CHANGED], 0,
1897                  compatible_target);
1898 }