pintos-os.org Git - pspp/blob - src/ui/gui/psppire-selector.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2007, 2009, 2010, 2012 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
  18 /*
  19   This module provides a widget, PsppireSelector derived from
  20   GtkButton.
  21
  22   It contains a GtkArrow, and is used for selecting objects from a
  23   GtkTreeView and putting them into a destination widget (often
  24   another GtkTreeView).  Typically this is used in psppire for
  25   selecting variables, thus:
  26
  27
  28   +----------------------------------------------------------+
  29   |                                                          |
  30   |     Source Widget                       Dest Widget      |
  31   |   +----------------+                 +----------------+  |
  32   |   | Variable0      |                 | Variable2      |  |
  33   |   | Variable1      |                 |                |  |
  34   |   | Variable3      |                 |                |  |
  35   |   |                |    Selector     |                |  |
  36   |   |                |                 |                |  |
  37   |   |                |    +------+     |                |  |
  38   |   |                |    | |\   |     |                |  |
  39   |   |                |    | | \  |     |                |  |
  40   |   |                |    | | /  |     |                |  |
  41   |   |                |    | |/   |     |                |  |
  42   |   |                |    +------+     |                |  |
  43   |   |                |                 |                |  |
  44   |   |                |                 |                |  |
  45   |   |                |                 |                |  |
  46   |   |                |                 |                |  |
  47   |   +----------------+                 +----------------+  |
  48   |                                                          |
  49   +----------------------------------------------------------+
  50
  51   The Source Widget is always a GtkTreeView.  The Dest Widget may be a
  52   GtkTreeView or a GtkEntry (other destination widgets may be
  53   supported in the future).
  54
  55   Widgets may be source to more than one PsppireSelector.
  56 */
  57
  58
  59 #include <config.h>
  60
  61 #include "psppire-dictview.h"
  62 #include "psppire-var-view.h"
  63 #include "psppire-dict.h"
  64 #include "psppire-select-dest.h"
  65
  66 #include <gtk/gtk.h>
  67
  68 #include "psppire-selector.h"
  69
  70 static void psppire_selector_class_init    (PsppireSelectorClass *class);
  71 static void psppire_selector_init          (PsppireSelector      *selector);
  72
  73
  74 static void set_direction (PsppireSelector *, enum psppire_selector_dir);
  75
  76
  77 enum  {SELECTED,    /* Emitted when an item is inserted into dest */
  78        DE_SELECTED, /* Emitted when an item is removed from dest */
  79        n_SIGNALS};
  80
  81 static guint signals [n_SIGNALS];
  82
  83 /* Callback for when an item disappears from the source list.
  84    By implication, this means that the item has been inserted into the
  85    destination.
  86  */
  87 static void
  88 on_row_deleted (PsppireSelector *selector)
  89 {
  90   g_signal_emit (selector, signals [SELECTED], 0);
  91 }
  92
  93 /* Callback for when a new item appears in the source list.
  94    By implication, this means that an item has been deleted from the
  95    destination.
  96  */
  97 static void
  98 on_row_inserted (PsppireSelector *selector)
  99 {
 100   g_signal_emit (selector, signals [DE_SELECTED], 0);
 101 }
 102
 103
 104 GType
 105 psppire_selector_get_type (void)
 106 {
 107   static GType psppire_selector_type = 0;
 108
 109   if (!psppire_selector_type)
 110     {
 111       static const GTypeInfo psppire_selector_info =
 112       {
 113         sizeof (PsppireSelectorClass),
 114         (GBaseInitFunc) NULL,
 115         (GBaseFinalizeFunc) NULL,
 116         (GClassInitFunc)psppire_selector_class_init,
 117         (GClassFinalizeFunc) NULL,
 118         NULL,
 119         sizeof (PsppireSelector),
 120         0,
 121         (GInstanceInitFunc) psppire_selector_init,
 122       };
 123
 124       psppire_selector_type =
 125         g_type_register_static (GTK_TYPE_BUTTON, "PsppireSelector",
 126                                 &psppire_selector_info, 0);
 127     }
 128
 129   return psppire_selector_type;
 130 }
 131
 132 static GObjectClass * parent_class = NULL;
 133
 134
 135
 136 #define SELECTOR_DEBUGGING 0
 137
 138 static void
 139 dump_hash_entry (gpointer key, gpointer value, gpointer obj)
 140 {
 141   GList *item = NULL;
 142   g_print ("Source %p; ", key);
 143
 144   for (item = g_list_first (value);
 145        item != NULL;
 146        item = g_list_next (item))
 147     {
 148       g_print ("%p(%p) ", item->data, item);
 149     }
 150   g_print ("\n");
 151 }
 152
 153 /* This function is for debugging only */
 154 void
 155 psppire_selector_show_map (PsppireSelector *obj)
 156 {
 157   PsppireSelectorClass *class = g_type_class_peek (PSPPIRE_SELECTOR_TYPE);
 158
 159   g_print ("%s %p\n", __FUNCTION__, obj);
 160   g_hash_table_foreach (class->source_hash, dump_hash_entry, obj);
 161 }
 162
 163
 164
 165 static void
 166 psppire_selector_dispose (GObject *obj)
 167 {
 168   PsppireSelector *sel = PSPPIRE_SELECTOR (obj);
 169   PsppireSelectorClass *class = g_type_class_peek (PSPPIRE_SELECTOR_TYPE);
 170   GList *list;
 171
 172   if (sel->dispose_has_run)
 173     return;
 174
 175   /* Make sure dispose does not run twice. */
 176   sel->dispose_has_run = TRUE;
 177
 178   /* Remove ourself from the source map. If we are the only entry for this source
 179      widget, that will result in an empty list for the source.  In that case, we
 180      remove the entire entry too. */
 181   if ((list = g_hash_table_lookup (class->source_hash, sel->source)))
 182     {
 183       GList *newlist = g_list_remove_link (list, sel->source_litem);
 184       g_list_free (sel->source_litem);
 185       if (newlist == NULL)
 186         g_hash_table_remove (class->source_hash, sel->source);
 187       else
 188         g_hash_table_replace (class->source_hash, sel->source, newlist);
 189
 190       sel->source_litem = NULL;
 191     }
 192
 193   g_object_unref (sel->dest);
 194   g_object_unref (sel->source);
 195
 196   /* Chain up to the parent class */
 197   G_OBJECT_CLASS (parent_class)->dispose (obj);
 198 }
 199
 200
 201 /* Properties */
 202 enum
 203 {
 204   PROP_0,
 205   PROP_ORIENTATION,
 206   PROP_PRIMARY,
 207   PROP_SOURCE_WIDGET,
 208   PROP_DEST_WIDGET
 209 };
 210
 211
 212 static void on_click (GtkButton *b);
 213 static void on_realize (GtkWidget *selector);
 214
 215
 216 static void update_subjects (PsppireSelector *selector);
 217
 218
 219 static void
 220 psppire_selector_set_property (GObject         *object,
 221                                guint            prop_id,
 222                                const GValue    *value,
 223                                GParamSpec      *pspec)
 224 {
 225   PsppireSelector *selector = PSPPIRE_SELECTOR (object);
 226
 227   switch (prop_id)
 228     {
 229     case PROP_ORIENTATION:
 230       selector->orientation = g_value_get_enum (value);
 231       set_direction (selector, selector->direction);
 232       break;
 233     case PROP_PRIMARY:
 234       selector->primary_requested = TRUE;
 235       update_subjects (selector);
 236       break;
 237     case PROP_SOURCE_WIDGET:
 238       selector->source = g_value_dup_object (value);
 239       update_subjects (selector);
 240       break;
 241     case PROP_DEST_WIDGET:
 242       selector->dest = g_value_dup_object (value);
 243       update_subjects (selector);
 244       break;
 245     default:
 246       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 247       break;
 248     };
 249 }
 250
 251
 252 static void
 253 psppire_selector_get_property (GObject         *object,
 254                                guint            prop_id,
 255                                GValue          *value,
 256                                GParamSpec      *pspec)
 257 {
 258   PsppireSelector *selector = PSPPIRE_SELECTOR (object);
 259
 260   switch (prop_id)
 261     {
 262     case PROP_ORIENTATION:
 263       g_value_set_enum (value, selector->orientation);
 264       break;
 265     case PROP_SOURCE_WIDGET:
 266       g_value_take_object (value, selector->source);
 267       break;
 268     case PROP_DEST_WIDGET:
 269       g_value_take_object (value, selector->dest);
 270       break;
 271     default:
 272       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 273       break;
 274     };
 275 }
 276
 277 static void
 278 psppire_selector_class_init (PsppireSelectorClass *class)
 279 {
 280   GObjectClass *object_class = G_OBJECT_CLASS (class);
 281   GtkButtonClass *button_class = GTK_BUTTON_CLASS (class);
 282   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 283   GParamSpec *orientation_spec =
 284     g_param_spec_enum ("orientation",
 285                        "Orientation",
 286                        "Where the selector is relative to its subjects",
 287                        PSPPIRE_TYPE_SELECTOR_ORIENTATION,
 288                        PSPPIRE_SELECT_SOURCE_BEFORE_DEST /* default value */,
 289                        G_PARAM_CONSTRUCT_ONLY |G_PARAM_READWRITE);
 290
 291
 292  /* Meaningfull only if more than one selector shares this selectors source */
 293   GParamSpec *primary_spec =
 294     g_param_spec_boolean ("primary",
 295                           "Primary",
 296                           "Whether this selector should be the primary selector for the source",
 297                           FALSE,
 298                           G_PARAM_READWRITE);
 299
 300   GParamSpec *source_widget_spec =
 301     g_param_spec_object ("source-widget",
 302                          "Source Widget",
 303                          "The widget to be used as the source for this selector",
 304                          GTK_TYPE_WIDGET,
 305                          G_PARAM_READWRITE);
 306
 307   GParamSpec *dest_widget_spec =
 308     g_param_spec_object ("dest-widget",
 309                          "Destination Widget",
 310                          "The widget to be used as the destination for this selector",
 311                          GTK_TYPE_WIDGET,
 312                          G_PARAM_READWRITE);
 313
 314
 315   button_class->clicked = on_click;
 316   widget_class->realize = on_realize;
 317
 318
 319   object_class->set_property = psppire_selector_set_property;
 320   object_class->get_property = psppire_selector_get_property;
 321
 322   g_object_class_install_property (object_class,
 323                                    PROP_ORIENTATION,
 324                                    orientation_spec);
 325
 326   g_object_class_install_property (object_class,
 327                                    PROP_PRIMARY,
 328                                    primary_spec);
 329
 330   g_object_class_install_property (object_class,
 331                                    PROP_SOURCE_WIDGET,
 332                                    source_widget_spec);
 333
 334   g_object_class_install_property (object_class,
 335                                    PROP_DEST_WIDGET,
 336                                    dest_widget_spec);
 337
 338   parent_class = g_type_class_peek_parent (class);
 339
 340   signals [SELECTED] =
 341     g_signal_new ("selected",
 342                   G_TYPE_FROM_CLASS (class),
 343                   G_SIGNAL_RUN_FIRST,
 344                   0,
 345                   NULL, NULL,
 346                   g_cclosure_marshal_VOID__VOID,
 347                   G_TYPE_NONE,
 348                   0);
 349
 350   signals [DE_SELECTED] =
 351     g_signal_new ("de-selected",
 352                   G_TYPE_FROM_CLASS (class),
 353                   G_SIGNAL_RUN_FIRST,
 354                   0,
 355                   NULL, NULL,
 356                   g_cclosure_marshal_VOID__VOID,
 357                   G_TYPE_NONE,
 358                   0);
 359
 360   object_class->dispose = psppire_selector_dispose;
 361
 362   class->source_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
 363   class->default_selection_funcs = g_hash_table_new (g_direct_hash, g_direct_equal);
 364 }
 365
 366
 367 /* Callback for when the source treeview is activated (double clicked) */
 368 static void
 369 on_row_activate (GtkTreeView       *tree_view,
 370                  GtkTreePath       *path,
 371                  GtkTreeViewColumn *column,
 372                  gpointer           data)
 373 {
 374   on_click (GTK_BUTTON (data));
 375 }
 376
 377 /* Callback for when the source selection changes */
 378 static void
 379 on_source_select (GtkTreeSelection *treeselection, gpointer data)
 380 {
 381   PsppireSelector *selector = data;
 382
 383   set_direction (selector, PSPPIRE_SELECTOR_SOURCE_TO_DEST);
 384
 385   if ( selector->allow_selection )
 386     {
 387       gtk_widget_set_sensitive (GTK_WIDGET (selector),
 388                                 selector->allow_selection (selector->source, selector->dest));
 389     }
 390   else if ( GTK_IS_ENTRY (selector->dest) )
 391     {
 392       gtk_widget_set_sensitive (GTK_WIDGET (selector),
 393                                 gtk_tree_selection_count_selected_rows
 394                                 (treeselection) <= 1 );
 395     }
 396 }
 397
 398
 399 static void
 400 on_realize (GtkWidget *w)
 401 {
 402   PsppireSelector *selector = PSPPIRE_SELECTOR (w);
 403   PsppireSelectorClass *class = g_type_class_peek (PSPPIRE_SELECTOR_TYPE);
 404   GtkTreeSelection* selection ;
 405
 406   GList *list = g_hash_table_lookup (class->source_hash, selector->source);
 407
 408   if (GTK_WIDGET_CLASS (parent_class)->realize)
 409     GTK_WIDGET_CLASS (parent_class)->realize (w);
 410
 411   if ( NULL == list)
 412     return;
 413
 414   if ( g_list_first (list)->data == selector)
 415     {
 416       if ( selector->row_activate_id )
 417         g_signal_handler_disconnect (selector->source, selector->row_activate_id);
 418
 419       selector->row_activate_id =
 420         g_signal_connect (selector->source, "row-activated", G_CALLBACK (on_row_activate), selector);
 421     }
 422
 423   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (selector->source));
 424
 425   if ( selector->source_select_id )
 426     g_signal_handler_disconnect (selection, selector->source_select_id);
 427
 428   selector->source_select_id =
 429     g_signal_connect (selection, "changed", G_CALLBACK (on_source_select), selector);
 430 }
 431
 432
 433 static void
 434 psppire_selector_init (PsppireSelector *selector)
 435 {
 436   selector->primary_requested = FALSE;
 437   selector->select_user_data = NULL;
 438   selector->select_items = NULL;
 439   selector->allow_selection = NULL;
 440   selector->filter = NULL;
 441
 442   selector->arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_NONE);
 443
 444
 445   gtk_container_add (GTK_CONTAINER (selector), selector->arrow);
 446
 447   gtk_widget_show (selector->arrow);
 448
 449   selector->selecting = FALSE;
 450
 451   selector->source = NULL;
 452   selector->dest = NULL;
 453   selector->dispose_has_run = FALSE;
 454
 455
 456   selector->row_activate_id = 0;
 457   selector->source_select_id  = 0;
 458
 459   selector->source_litem = NULL;
 460 }
 461
 462
 463 GtkWidget*
 464 psppire_selector_new (void)
 465 {
 466   return GTK_WIDGET (g_object_new (psppire_selector_get_type (), NULL));
 467 }
 468
 469
 470 static void
 471 set_direction (PsppireSelector *selector, enum psppire_selector_dir d)
 472 {
 473   selector->direction = d;
 474
 475   /* FIXME: Need to reverse the arrow direction if an RTL locale is in
 476      effect */
 477   if ( d == PSPPIRE_SELECTOR_SOURCE_TO_DEST )
 478     {
 479       switch (selector->orientation)
 480         {
 481         case   PSPPIRE_SELECT_SOURCE_BEFORE_DEST:
 482           g_object_set (selector->arrow, "arrow-type", GTK_ARROW_RIGHT, NULL);
 483           break;
 484         case   PSPPIRE_SELECT_SOURCE_AFTER_DEST:
 485           g_object_set (selector->arrow, "arrow-type", GTK_ARROW_LEFT, NULL);
 486           break;
 487         case   PSPPIRE_SELECT_SOURCE_ABOVE_DEST:
 488           g_object_set (selector->arrow, "arrow-type", GTK_ARROW_DOWN, NULL);
 489           break;
 490         case   PSPPIRE_SELECT_SOURCE_BELOW_DEST:
 491           g_object_set (selector->arrow, "arrow-type", GTK_ARROW_UP, NULL);
 492           break;
 493         default:
 494           g_assert_not_reached ();
 495           break;
 496         };
 497     }
 498   else
 499     {
 500       switch (selector->orientation)
 501         {
 502         case   PSPPIRE_SELECT_SOURCE_BEFORE_DEST:
 503           g_object_set (selector->arrow, "arrow-type", GTK_ARROW_LEFT, NULL);
 504           break;
 505         case   PSPPIRE_SELECT_SOURCE_AFTER_DEST:
 506           g_object_set (selector->arrow, "arrow-type", GTK_ARROW_RIGHT, NULL);
 507           break;
 508         case   PSPPIRE_SELECT_SOURCE_ABOVE_DEST:
 509           g_object_set (selector->arrow, "arrow-type", GTK_ARROW_UP, NULL);
 510           break;
 511         case   PSPPIRE_SELECT_SOURCE_BELOW_DEST:
 512           g_object_set (selector->arrow, "arrow-type", GTK_ARROW_DOWN, NULL);
 513           break;
 514         default:
 515           g_assert_not_reached ();
 516           break;
 517         };
 518
 519     }
 520 }
 521
 522 /* Callback for when the destination treeview selection changes */
 523 static void
 524 on_dest_treeview_select (GtkTreeSelection *treeselection, gpointer data)
 525 {
 526   PsppireSelector *selector = data;
 527
 528   gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (selector->source)));
 529
 530   set_direction (selector, PSPPIRE_SELECTOR_DEST_TO_SOURCE);
 531 }
 532
 533 /* Callback for source deselection, when the dest is GtkEntry */
 534 static void
 535 de_select_selection_entry (PsppireSelector *selector)
 536 {
 537   gtk_entry_set_text (GTK_ENTRY (selector->dest), "");
 538 }
 539
 540 /* Callback for source deselection, when the dest is GtkTreeView */
 541 static void
 542 de_select_selection_tree_view (PsppireSelector *selector)
 543 {
 544   GList *item;
 545
 546   GtkTreeSelection* selection =
 547     gtk_tree_view_get_selection ( GTK_TREE_VIEW (selector->dest));
 548
 549   GtkTreeModel *model =
 550     gtk_tree_view_get_model (GTK_TREE_VIEW (selector->dest));
 551
 552   GList *selected_rows =
 553     gtk_tree_selection_get_selected_rows (selection, NULL);
 554
 555   g_return_if_fail (selector->select_items);
 556
 557   /* Convert paths to RowRefs */
 558   for (item = g_list_first (selected_rows);
 559        item != NULL;
 560        item = g_list_next (item))
 561     {
 562       GtkTreeRowReference* rowref;
 563       GtkTreePath *path  = item->data;
 564
 565       rowref = gtk_tree_row_reference_new (GTK_TREE_MODEL (model), path);
 566
 567       item->data = rowref ;
 568       gtk_tree_path_free (path);
 569     }
 570
 571   /* Remove each selected row from the dest widget */
 572   for (item = g_list_first (selected_rows);
 573        item != NULL;
 574        item = g_list_next (item))
 575     {
 576       GtkTreeIter iter;
 577       GtkTreeRowReference *rr = item->data;
 578
 579       GtkTreePath *path = gtk_tree_row_reference_get_path (rr);
 580
 581       gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path);
 582
 583       gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
 584
 585       gtk_tree_path_free (path);
 586     }
 587
 588   /* Delete list of RowRefs and its contents */
 589   g_list_foreach (selected_rows, (GFunc) gtk_tree_row_reference_free, NULL);
 590   g_list_free (selected_rows);
 591 }
 592
 593
 594 /* Callback which causes the filter to be refiltered.
 595    Called when the DEST GtkEntry is activated (Enter is pressed), or when it
 596    looses focus.
 597 */
 598 static gboolean
 599 refilter (PsppireSelector *selector)
 600 {
 601   GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (selector->source));
 602   if (GTK_IS_TREE_MODEL_FILTER (model))
 603     gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
 604   return FALSE;
 605 }
 606
 607 /* Removes something from the DEST widget */
 608 static void
 609 de_select_selection (PsppireSelector *selector)
 610 {
 611   selector->selecting = TRUE;
 612
 613   if ( GTK_IS_TREE_VIEW (selector->dest ) )
 614     de_select_selection_tree_view (selector);
 615
 616   else if ( GTK_IS_ENTRY (selector->dest))
 617     de_select_selection_entry (selector);
 618
 619   else
 620     g_assert_not_reached ();
 621
 622   selector->selecting = FALSE;
 623
 624   refilter (selector);
 625
 626   g_signal_emit (selector, signals [DE_SELECTED], 0);
 627 }
 628
 629
 630 /* Puts something into the DEST widget */
 631 static void
 632 select_selection (PsppireSelector *selector)
 633 {
 634   GList *item ;
 635   GtkTreeSelection* selection =
 636     gtk_tree_view_get_selection ( GTK_TREE_VIEW (selector->source));
 637
 638   GList *selected_rows = gtk_tree_selection_get_selected_rows (selection, NULL);
 639
 640   GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (selector->source));
 641
 642   GtkTreeModel *childmodel = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
 643
 644   g_return_if_fail (selector->select_items);
 645
 646   if (selector->allow_selection &&
 647       ! selector->allow_selection (selector->source, selector->dest))
 648     return;
 649
 650   selector->selecting = TRUE;
 651
 652   for (item = g_list_first (selected_rows);
 653        item != NULL;
 654        item = g_list_next (item))
 655     {
 656       GtkTreeIter child_iter;
 657       GtkTreeIter iter;
 658       GtkTreePath *path  = item->data;
 659
 660       g_return_if_fail (model);
 661
 662       gtk_tree_model_get_iter (model, &iter, path);
 663
 664       gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model),
 665                                                         &child_iter, &iter);
 666       selector->select_items (child_iter,
 667                               selector->dest,
 668                               childmodel,
 669                               selector->select_user_data
 670                               );
 671     }
 672
 673   g_list_foreach (selected_rows, (GFunc) gtk_tree_path_free, NULL);
 674   g_list_free (selected_rows);
 675
 676   refilter (selector);
 677
 678   g_signal_emit (selector, signals [SELECTED], 0);
 679
 680   selector->selecting = FALSE;
 681 }
 682
 683 /* Callback for when the selector button is clicked,
 684    or other event which causes the selector's action to occur.
 685  */
 686 static void
 687 on_click (GtkButton *b)
 688 {
 689   PsppireSelector *selector = PSPPIRE_SELECTOR (b);
 690
 691   switch (selector->direction)
 692     {
 693     case PSPPIRE_SELECTOR_SOURCE_TO_DEST:
 694       select_selection (selector);
 695       break;
 696     case PSPPIRE_SELECTOR_DEST_TO_SOURCE:
 697       de_select_selection (selector);
 698       break;
 699     default:
 700       g_assert_not_reached ();
 701       break;
 702     }
 703
 704   if (GTK_BUTTON_CLASS (parent_class)->clicked)
 705     GTK_BUTTON_CLASS (parent_class)->clicked (b);
 706 }
 707
 708 static gboolean
 709 is_item_in_dest (GtkTreeModel *model, GtkTreeIter *iter, PsppireSelector *selector)
 710 {
 711   gboolean result = FALSE;
 712   GtkTreeIter source_iter;
 713   GtkTreeModel *source_model;
 714   GValue value = {0};
 715
 716   if (GTK_IS_TREE_MODEL_FILTER (model))
 717     {
 718       source_model = gtk_tree_model_filter_get_model
 719         (GTK_TREE_MODEL_FILTER (model));
 720
 721       gtk_tree_model_filter_convert_iter_to_child_iter
 722         (GTK_TREE_MODEL_FILTER (model),  &source_iter, iter);
 723     }
 724   else
 725     {
 726       source_model = model;
 727       source_iter = *iter;
 728     }
 729
 730   gtk_tree_model_get_value (source_model, &source_iter, DICT_TVM_COL_VAR, &value);
 731
 732   result = psppire_select_dest_widget_contains_var (PSPPIRE_SELECT_DEST_WIDGET (selector->dest),
 733                                                     &value);
 734
 735   g_value_unset (&value);
 736
 737   return result;
 738 }
 739
 740
 741
 742 /* Visibility function for items in the SOURCE widget.
 743    Returns TRUE iff *all* the selectors for which SOURCE is associated
 744    are visible */
 745 static gboolean
 746 is_source_item_visible (GtkTreeModel *childmodel,
 747                         GtkTreeIter *iter, gpointer data)
 748 {
 749   PsppireSelector *selector = data;
 750   PsppireSelectorClass *class = g_type_class_peek (PSPPIRE_SELECTOR_TYPE);
 751
 752   GList *list = NULL;
 753
 754   list = g_hash_table_lookup (class->source_hash, selector->source);
 755
 756   while (list)
 757     {
 758       PsppireSelector *selector = list->data;
 759
 760       if ( selector->filter && selector->filter (childmodel, iter, selector))
 761         return FALSE;
 762
 763       list = list->next;
 764     }
 765
 766
 767   return TRUE;
 768 }
 769
 770 /* set the source widget to SOURCE */
 771 static void
 772 set_tree_view_source (PsppireSelector *selector)
 773 {
 774   GList *list = NULL;
 775
 776   PsppireSelectorClass *class = g_type_class_peek (PSPPIRE_SELECTOR_TYPE);
 777
 778   if ( ! (list = g_hash_table_lookup (class->source_hash, selector->source)))
 779     {
 780       /* Base case:  This widget is currently not the source of
 781          any selector.  Create a hash entry and make this selector
 782          the first selector in the list */
 783
 784       list = g_list_append (list, selector);
 785       g_hash_table_insert (class->source_hash, selector->source, list);
 786
 787       /* Save the list item so that it can be removed later */
 788       selector->source_litem = list;
 789     }
 790   else
 791     {  /* Append this selector to the list and push the <source,list>
 792           pair onto the hash table */
 793
 794       if ( NULL == g_list_find (list, selector) )
 795         {
 796           if ( selector->primary_requested )
 797             {
 798               list = g_list_prepend (list, selector);
 799               selector->source_litem = list;
 800             }
 801           else
 802             {
 803               list = g_list_append (list, selector);
 804               selector->source_litem = g_list_last (list);
 805             }
 806           g_hash_table_replace (class->source_hash, selector->source, list);
 807         }
 808     }
 809 }
 810
 811
 812
 813 /* This function is a callback which occurs when the
 814    SOURCE's model has changed */
 815 static void
 816 update_model (
 817               GtkTreeView *source,
 818               GParamSpec *psp,
 819               PsppireSelector *selector
 820               )
 821 {
 822   GtkTreeModel *model = gtk_tree_view_get_model (source);
 823
 824   g_assert (source == GTK_TREE_VIEW (selector->source));
 825
 826   if (model && (model == g_object_get_data (G_OBJECT (source), "model-copy")))
 827     return;
 828
 829   if (model != NULL)
 830     {
 831       GtkTreeModel *new_model = gtk_tree_model_filter_new (model, NULL);
 832
 833       g_object_set_data (G_OBJECT (source), "model-copy", new_model);
 834
 835       gtk_tree_view_set_model (source, new_model);
 836
 837       gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (new_model),
 838                                               is_source_item_visible,
 839                                               selector,
 840                                               NULL);
 841
 842       g_signal_connect_swapped (new_model,
 843                                 "row-deleted",
 844                                 G_CALLBACK (on_row_deleted), selector);
 845
 846       g_signal_connect_swapped (new_model,
 847                                 "row-inserted",
 848                                 G_CALLBACK (on_row_inserted), selector);
 849
 850       g_object_unref (new_model);
 851     }
 852 }
 853
 854
 855
 856 /*
 857    Callback for when the destination treeview's data changes
 858  */
 859 static void
 860 on_dest_data_change (GtkTreeModel *tree_model,
 861                      GtkTreePath  *path,
 862                      GtkTreeIter  *iter,
 863                      gpointer      user_data)
 864 {
 865   PsppireSelector *selector = user_data;
 866
 867   if ( selector->selecting) return;
 868
 869   refilter (selector);
 870 }
 871
 872
 873 static void
 874 on_dest_data_delete (GtkTreeModel *tree_model,
 875                      GtkTreePath  *path,
 876                      gpointer      user_data)
 877 {
 878   PsppireSelector *selector = user_data;
 879
 880   if ( selector->selecting ) return;
 881
 882   refilter (selector);
 883 }
 884
 885
 886 static void
 887 remove_selector_handlers (PsppireSelector *selector, GObject *sel)
 888 {
 889   g_signal_handlers_disconnect_by_data (sel, selector);
 890 }
 891
 892 static void
 893 on_dest_model_changed (PsppireSelector *selector)
 894 {
 895   GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (selector->dest));
 896
 897   if (model == NULL)
 898     return;
 899
 900   g_signal_connect (model, "row-changed", G_CALLBACK (on_dest_data_change),
 901                     selector);
 902
 903   g_signal_connect (model, "row-deleted", G_CALLBACK (on_dest_data_delete),
 904                     selector);
 905
 906   g_signal_connect (selector, "destroy", G_CALLBACK (remove_selector_handlers), model);
 907
 908   if ( selector->selecting ) return;
 909
 910   refilter (selector);
 911 }
 912
 913 /* Set the destination widget to DEST */
 914 static void
 915 set_tree_view_dest (PsppireSelector *selector,
 916                     GtkTreeView *dest)
 917 {
 918   GtkTreeSelection* selection = gtk_tree_view_get_selection (dest);
 919
 920
 921   gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
 922
 923   g_signal_connect (selection, "changed", G_CALLBACK (on_dest_treeview_select),
 924                     selector);
 925
 926   on_dest_model_changed (selector);
 927   g_signal_connect_swapped (dest, "notify::model",
 928                             G_CALLBACK (on_dest_model_changed), selector);
 929 }
 930
 931
 932
 933
 934 /* Callback for when the DEST GtkEntry is selected (clicked) */
 935 static gboolean
 936 on_entry_dest_select (GtkWidget *widget, GdkEventFocus *event, gpointer data)
 937 {
 938   PsppireSelector * selector = data;
 939
 940   gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (selector->source)));
 941   set_direction (selector, PSPPIRE_SELECTOR_DEST_TO_SOURCE);
 942
 943   return FALSE;
 944 }
 945
 946
 947
 948 /* Set DEST to be the destination GtkEntry widget */
 949 static void
 950 set_entry_dest (PsppireSelector *selector,
 951                 GtkEntry *dest)
 952 {
 953   g_signal_connect_swapped (dest, "activate", G_CALLBACK (refilter),
 954                     selector);
 955
 956   g_signal_connect_swapped (dest, "changed", G_CALLBACK (refilter),
 957                     selector);
 958
 959   g_signal_connect (dest, "focus-in-event", G_CALLBACK (on_entry_dest_select),
 960                     selector);
 961
 962   g_signal_connect_swapped (dest, "focus-out-event", G_CALLBACK (refilter),
 963                     selector);
 964
 965
 966 }
 967
 968 static void
 969 set_default_filter (PsppireSelector *selector)
 970 {
 971   if ( selector->filter == NULL)
 972     {
 973       if  (GTK_IS_TREE_VIEW (selector->dest))
 974         selector->filter = is_item_in_dest;
 975     }
 976 }
 977
 978
 979 static void
 980 update_subjects (PsppireSelector *selector)
 981 {
 982   if ( NULL == selector->dest )
 983     return;
 984
 985   set_default_filter (selector);
 986
 987   if ( NULL == selector->source )
 988     return;
 989
 990   if ( GTK_IS_TREE_VIEW (selector->source))
 991     {
 992       set_tree_view_source (selector);
 993
 994       g_signal_connect (selector->source, "notify::model",
 995                               G_CALLBACK (update_model), selector);
 996
 997       update_model (GTK_TREE_VIEW (selector->source), 0, selector);
 998     }
 999   else
1000     g_error ("Unsupported source widget: %s", G_OBJECT_TYPE_NAME (selector->source));
1001
1002   if ( NULL == selector->dest)
1003     ;
1004   else if  ( GTK_IS_TREE_VIEW (selector->dest))
1005     {
1006       set_tree_view_dest (selector, GTK_TREE_VIEW (selector->dest));
1007     }
1008
1009   else if ( GTK_IS_ENTRY (selector->dest))
1010     set_entry_dest (selector, GTK_ENTRY (selector->dest));
1011
1012   else if (GTK_IS_TEXT_VIEW (selector->dest))
1013     {
1014       /* Nothing to be done */
1015     }
1016   else
1017     g_error ("Unsupported destination widget: %s", G_OBJECT_TYPE_NAME (selector->dest));
1018
1019
1020   /* FIXME: Remove this dependency */
1021   if ( PSPPIRE_IS_DICT_VIEW (selector->source) )
1022     {
1023       GObjectClass *class = G_OBJECT_GET_CLASS (selector);
1024       GType type = G_OBJECT_TYPE (selector->dest);
1025
1026       SelectItemsFunc *func  =
1027         g_hash_table_lookup (PSPPIRE_SELECTOR_CLASS (class)->default_selection_funcs, (gpointer) type);
1028
1029       if ( func )
1030         psppire_selector_set_select_func (PSPPIRE_SELECTOR (selector),
1031                                           func, NULL);
1032     }
1033 }
1034
1035
1036 void
1037 psppire_selector_set_default_selection_func (GType type, SelectItemsFunc *func)
1038 {
1039   GObjectClass *class = g_type_class_ref (PSPPIRE_SELECTOR_TYPE);
1040
1041   g_hash_table_insert (PSPPIRE_SELECTOR_CLASS (class)->default_selection_funcs, (gpointer) type, func);
1042
1043   g_type_class_unref (class);
1044 }
1045
1046
1047
1048
1049 /* Set FILTER_FUNC for this selector */
1050 void
1051 psppire_selector_set_filter_func (PsppireSelector *selector,
1052                                   FilterItemsFunc *filter_func)
1053 {
1054   selector->filter = filter_func ;
1055 }
1056
1057
1058 /* Set SELECT_FUNC for this selector */
1059 void
1060 psppire_selector_set_select_func (PsppireSelector *selector,
1061                                SelectItemsFunc *select_func,
1062                                gpointer user_data)
1063 {
1064   selector->select_user_data = user_data;
1065   selector->select_items = select_func;
1066 }
1067
1068
1069
1070 void
1071 psppire_selector_set_allow (PsppireSelector *selector, AllowSelectionFunc *allow)
1072 {
1073   selector->allow_selection = allow;
1074 }
1075
1076
1077 GType
1078 psppire_selector_orientation_get_type (void)
1079 {
1080   static GType etype = 0;
1081   if (etype == 0) {
1082     static const GEnumValue values[] = {
1083       { PSPPIRE_SELECT_SOURCE_BEFORE_DEST, "PSPPIRE_SELECT_SOURCE_BEFORE_DEST", "source before destination" },
1084       { PSPPIRE_SELECT_SOURCE_AFTER_DEST, "PSPPIRE_SELECT_SOURCE_AFTER_DEST", "source after destination" },
1085       { PSPPIRE_SELECT_SOURCE_ABOVE_DEST, "PSPPIRE_SELECT_SOURCE_ABOVE_DEST", "source above destination" },
1086       { PSPPIRE_SELECT_SOURCE_BELOW_DEST, "PSPPIRE_SELECT_SOURCE_BELOW_DEST", "source below destination" },
1087       { 0, NULL, NULL }
1088     };
1089     etype = g_enum_register_static (g_intern_static_string ("PsppireSelectorOrientation"), values);
1090   }
1091   return etype;
1092 }