X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fui%2Fgui%2Fpsppire-var-sheet.c;h=35e276cad3f8a0b837ddc0de78bf91dddd7b333e;hb=e616e74c79756510aa504b4a2885b2a9b18ed546;hp=222694dcec84d9f19d6f73f20fedc45446fb2cfb;hpb=51207cb594aecd5def535f872638cb3e94ff850a;p=pspp diff --git a/src/ui/gui/psppire-var-sheet.c b/src/ui/gui/psppire-var-sheet.c index 222694dcec..35e276cad3 100644 --- a/src/ui/gui/psppire-var-sheet.c +++ b/src/ui/gui/psppire-var-sheet.c @@ -1,5 +1,5 @@ /* PSPPIRE - a graphical user interface for PSPP. - Copyright (C) 2011, 2012 Free Software Foundation, Inc. + Copyright (C) 2008, 2009, 2011, 2012, 2013, 2014 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -29,9 +29,11 @@ #include "ui/gui/psppire-data-editor.h" #include "ui/gui/psppire-data-window.h" #include "ui/gui/psppire-dialog-action-var-info.h" +#include "ui/gui/psppire-dictview.h" #include "ui/gui/psppire-empty-list-store.h" #include "ui/gui/psppire-marshal.h" #include "ui/gui/val-labs-dialog.h" +#include "ui/gui/var-type-dialog.h" #include "ui/gui/var-display.h" #include "ui/gui/var-type-dialog.h" @@ -52,7 +54,8 @@ enum vs_column VS_MISSING, VS_COLUMNS, VS_ALIGN, - VS_MEASURE + VS_MEASURE, + VS_ROLE }; G_DEFINE_TYPE (PsppireVarSheet, psppire_var_sheet, PSPP_TYPE_SHEET_VIEW); @@ -140,6 +143,19 @@ scroll_to_bottom (GtkWidget *widget, } } +static struct variable * +path_string_to_var (PsppireVarSheet *var_sheet, gchar *path_string) +{ + GtkTreePath *path; + gint row; + + path = gtk_tree_path_new_from_string (path_string); + row = gtk_tree_path_get_indices (path)[0]; + gtk_tree_path_free (path); + + return psppire_dict_get_variable (var_sheet->dict, row); +} + static void on_var_column_edited (GtkCellRendererText *cell, gchar *path_string, @@ -152,17 +168,11 @@ on_var_column_edited (GtkCellRendererText *cell, enum vs_column column_id; struct variable *var; int width, decimals; - GtkTreePath *path; - gint row; - - path = gtk_tree_path_new_from_string (path_string); - row = gtk_tree_path_get_indices (path)[0]; - gtk_tree_path_free (path); column_id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-id")); - var = psppire_dict_get_variable (var_sheet->dict, row); + var = path_string_to_var (var_sheet, path_string); if (var == NULL) { g_return_if_fail (column_id == VS_NAME); @@ -185,7 +195,7 @@ on_var_column_edited (GtkCellRendererText *cell, { gtk_widget_queue_resize (GTK_WIDGET (var_sheet)); var_sheet->scroll_to_bottom_signal = - g_signal_connect (var_sheet, "size-request", + g_signal_connect (var_sheet, "size-allocate", G_CALLBACK (scroll_to_bottom), NULL); } } @@ -224,8 +234,8 @@ on_var_column_edited (GtkCellRendererText *cell, format = *var_get_print_format (var); fmt_change_width (&format, width, var_sheet->format_use); - var_set_print_format (var, &format); var_set_width (var, fmt_var_width (&format)); + var_set_both_formats (var, &format); } break; @@ -242,7 +252,7 @@ on_var_column_edited (GtkCellRendererText *cell, break; case VS_LABEL: - var_set_label (var, new_text, false); + var_set_label (var, new_text); break; case VS_VALUES: @@ -272,6 +282,21 @@ on_var_column_edited (GtkCellRendererText *cell, else if (!strcmp (new_text, measure_to_string (MEASURE_SCALE))) var_set_measure (var, MEASURE_SCALE); break; + + case VS_ROLE: + if (!strcmp (new_text, var_role_to_string (ROLE_INPUT))) + var_set_role (var, ROLE_INPUT); + else if (!strcmp (new_text, var_role_to_string (ROLE_TARGET))) + var_set_role (var, ROLE_TARGET); + else if (!strcmp (new_text, var_role_to_string (ROLE_BOTH))) + var_set_role (var, ROLE_BOTH); + else if (!strcmp (new_text, var_role_to_string (ROLE_NONE))) + var_set_role (var, ROLE_NONE); + else if (!strcmp (new_text, var_role_to_string (ROLE_PARTITION))) + var_set_role (var, ROLE_PARTITION); + else if (!strcmp (new_text, var_role_to_string (ROLE_SPLIT))) + var_set_role (var, ROLE_SPLIT); + break; } } @@ -291,6 +316,35 @@ render_popup_cell (PsppSheetViewColumn *tree_column, NULL); } +const char * +get_var_align_stock_id (enum alignment alignment) +{ + switch (alignment) + { + case ALIGN_LEFT: return "align-left"; + case ALIGN_CENTRE: return "align-center"; + case ALIGN_RIGHT: return "align-right"; + default: + g_return_val_if_reached (""); + } +} + +const char * +get_var_role_stock_id (enum var_role role) +{ + switch (role) + { + case ROLE_INPUT: return "role-input"; + case ROLE_TARGET: return "role-target"; + case ROLE_BOTH: return "role-both"; + case ROLE_NONE: return "role-none"; + case ROLE_PARTITION: return "role-partition"; + case ROLE_SPLIT: return "role-split"; + default: + g_return_val_if_reached (""); + } +} + static void render_var_cell (PsppSheetViewColumn *tree_column, GtkCellRenderer *cell, @@ -308,16 +362,24 @@ render_var_cell (PsppSheetViewColumn *tree_column, "column-number")) - 1; row = GPOINTER_TO_INT (iter->user_data); + gtk_cell_renderer_set_visible (cell, true); if (row >= psppire_dict_get_var_cnt (var_sheet->dict)) { - g_object_set (cell, - "text", "", - "editable", column_id == VS_NAME, - NULL); - if (column_id == VS_WIDTH - || column_id == VS_DECIMALS - || column_id == VS_COLUMNS) - g_object_set (cell, "adjustment", NULL, NULL); + if (GTK_IS_CELL_RENDERER_TEXT (cell)) + { + g_object_set (cell, + "text", "", + "editable", column_id == VS_NAME, + NULL); + if (column_id == VS_WIDTH + || column_id == VS_DECIMALS + || column_id == VS_COLUMNS) + g_object_set (cell, "adjustment", NULL, NULL); + } + else + { + gtk_cell_renderer_set_visible (cell, false); + } return; } @@ -341,16 +403,10 @@ render_var_cell (PsppSheetViewColumn *tree_column, break; case VS_WIDTH: - { - int step = fmt_step_width (print->type); - if (var_is_numeric (var)) - set_spin_cell (cell, print->w, - fmt_min_width (print->type, var_sheet->format_use), - fmt_max_width (print->type, var_sheet->format_use), - step); - else - set_spin_cell (cell, print->w, 0, 0, step); - } + set_spin_cell (cell, print->w, + fmt_min_width (print->type, var_sheet->format_use), + fmt_max_width (print->type, var_sheet->format_use), + fmt_step_width (print->type)); break; case VS_DECIMALS: @@ -398,7 +454,7 @@ render_var_cell (PsppSheetViewColumn *tree_column, case VS_MISSING: { - char *text = missing_values_to_string (var_sheet->dict, var, NULL); + char *text = missing_values_to_string (var, NULL); g_object_set (cell, "text", text, "editable", FALSE, @@ -412,17 +468,42 @@ render_var_cell (PsppSheetViewColumn *tree_column, break; case VS_ALIGN: - g_object_set (cell, - "text", alignment_to_string (var_get_alignment (var)), - "editable", TRUE, - NULL); + if (GTK_IS_CELL_RENDERER_TEXT (cell)) + g_object_set (cell, + "text", alignment_to_string (var_get_alignment (var)), + "editable", TRUE, + NULL); + else + g_object_set (cell, "icon-name", + get_var_align_stock_id (var_get_alignment (var)), NULL); break; case VS_MEASURE: - g_object_set (cell, - "text", measure_to_string (var_get_measure (var)), - "editable", TRUE, - NULL); + if (GTK_IS_CELL_RENDERER_TEXT (cell)) + g_object_set (cell, + "text", measure_to_string (var_get_measure (var)), + "editable", TRUE, + NULL); + else + { + enum fmt_type type = var_get_print_format (var)->type; + enum measure measure = var_get_measure (var); + + g_object_set (cell, "icon-name", + get_var_measurement_stock_id (type, measure), + NULL); + } + break; + + case VS_ROLE: + if (GTK_IS_CELL_RENDERER_TEXT (cell)) + g_object_set (cell, + "text", var_role_to_string (var_get_role (var)), + "editable", TRUE, + NULL); + else + g_object_set (cell, "icon-name", + get_var_role_stock_id (var_get_role (var)), NULL); break; } } @@ -449,8 +530,17 @@ on_type_click (PsppireCellRendererButton *cell, gchar *path, PsppireVarSheet *var_sheet) { - var_sheet->var_type_dialog->pv = path_string_to_variable (var_sheet, path); - var_type_dialog_show (var_sheet->var_type_dialog); + GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (var_sheet)); + struct fmt_spec format; + struct variable *var; + + var = path_string_to_variable (var_sheet, path); + g_return_if_fail (var != NULL); + + format = *var_get_print_format (var); + psppire_var_type_dialog_run (GTK_WINDOW (toplevel), &format); + + var_set_width_and_formats (var, fmt_var_width (&format), &format, &format); } static void @@ -458,9 +548,19 @@ on_value_labels_click (PsppireCellRendererButton *cell, gchar *path, PsppireVarSheet *var_sheet) { - struct variable *var = path_string_to_variable (var_sheet, path); - val_labs_dialog_set_target_variable (var_sheet->val_labs_dialog, var); - val_labs_dialog_show (var_sheet->val_labs_dialog); + GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (var_sheet)); + struct val_labs *labels; + struct variable *var; + + var = path_string_to_variable (var_sheet, path); + g_return_if_fail (var != NULL); + + labels = psppire_val_labs_dialog_run (GTK_WINDOW (toplevel), var); + if (labels) + { + var_set_value_labels (var, labels); + val_labs_destroy (labels); + } } static void @@ -468,9 +568,16 @@ on_missing_values_click (PsppireCellRendererButton *cell, gchar *path, PsppireVarSheet *var_sheet) { - var_sheet->missing_val_dialog->pv = path_string_to_variable (var_sheet, - path); - missing_val_dialog_show (var_sheet->missing_val_dialog); + GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (var_sheet)); + struct missing_values mv; + struct variable *var; + + var = path_string_to_variable (var_sheet, path); + g_return_if_fail (var != NULL); + + psppire_missing_val_dialog_run (GTK_WINDOW (toplevel), var, &mv); + var_set_missing_values (var, &mv); + mv_destroy (&mv); } static gint @@ -481,8 +588,9 @@ get_string_width (PsppSheetView *treeview, GtkCellRenderer *renderer, g_object_set (G_OBJECT (renderer), PSPPIRE_IS_CELL_RENDERER_BUTTON (renderer) ? "label" : "text", string, (void *) NULL); - gtk_cell_renderer_get_size (renderer, GTK_WIDGET (treeview), - NULL, NULL, NULL, &width, NULL); + + gtk_cell_renderer_get_preferred_width (renderer, GTK_WIDGET (treeview), NULL, &width); + return width; } @@ -555,18 +663,85 @@ add_spin_column (PsppireVarSheet *var_sheet, enum vs_column column_id, column_id, title, width); } -static PsppSheetViewColumn * +static const char * +measure_to_stock_id (enum fmt_type type, int measure) +{ + return get_var_measurement_stock_id (type, measure); +} + +static const char * +alignment_to_stock_id (enum fmt_type type, int alignment) +{ + return get_var_align_stock_id (alignment); +} + +static const char * +role_to_stock_id (enum fmt_type type, int role) +{ + return get_var_role_stock_id (role); +} + +static void +render_var_pixbuf (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + GtkTreeModel *tree_model, + GtkTreeIter *iter, + gpointer data) +{ + const char *(*value_to_stock_id) (enum fmt_type, int value); + enum fmt_type type = GPOINTER_TO_INT (data); + gint value; + + value_to_stock_id = g_object_get_data (G_OBJECT (cell), "value-to-stock-id"); + + gtk_tree_model_get (tree_model, iter, 0, &value, -1); + g_object_set (cell, "icon-name", value_to_stock_id (type, value), NULL); +} + +static void +on_combo_editing_started (GtkCellRenderer *renderer, + GtkCellEditable *editable, + gchar *path_string, + gpointer user_data) +{ + PsppireVarSheet *var_sheet = user_data; + + if (GTK_IS_COMBO_BOX (editable)) + { + struct variable *var = path_string_to_variable (var_sheet, path_string); + const struct fmt_spec *format = var_get_print_format (var); + const char *(*value_to_stock_id) (enum fmt_type, int value); + GtkCellRenderer *cell; + + value_to_stock_id = g_object_get_data (G_OBJECT (renderer), + "value-to-stock-id"); + + cell = gtk_cell_renderer_pixbuf_new (); + g_object_set (cell, "width", 16, "height", 16, NULL); + g_object_set_data (G_OBJECT (cell), + "value-to-stock-id", value_to_stock_id); + gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (editable), cell, FALSE); + gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (editable), cell, + render_var_pixbuf, + GINT_TO_POINTER (format->type), + NULL); + } +} + +static void add_combo_column (PsppireVarSheet *var_sheet, enum vs_column column_id, const char *title, int width, + const char *(*value_to_stock_id) (enum fmt_type, int value), ...) { + PsppSheetViewColumn *column; GtkCellRenderer *cell; GtkListStore *store; const char *name; va_list args; store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING); - va_start (args, width); + va_start (args, value_to_stock_id); while ((name = va_arg (args, const char *)) != NULL) { int value = va_arg (args, int); @@ -583,9 +758,22 @@ add_combo_column (PsppireVarSheet *var_sheet, enum vs_column column_id, "model", GTK_TREE_MODEL (store), "text-column", 1, NULL); + if (value_to_stock_id != NULL) + { + g_object_set_data (G_OBJECT (cell), + "value-to-stock-id", value_to_stock_id); + g_signal_connect (cell, "editing-started", + G_CALLBACK (on_combo_editing_started), + var_sheet); + } - return add_var_sheet_column (var_sheet, cell, column_id, title, width); + column = add_var_sheet_column (var_sheet, cell, column_id, title, width); + cell = gtk_cell_renderer_pixbuf_new (); + g_object_set (cell, "width", 16, "height", 16, NULL); + pspp_sheet_view_column_pack_end (column, cell, FALSE); + pspp_sheet_view_column_set_cell_data_func ( + column, cell, render_var_cell, var_sheet, NULL); } static void @@ -749,9 +937,21 @@ static void do_popup_menu (GtkWidget *widget, guint button, guint32 time) { PsppireVarSheet *var_sheet = PSPPIRE_VAR_SHEET (widget); - GtkWidget *menu; + GtkWidget *menu = gtk_menu_new (); + + int i = 0; - menu = get_widget_assert (var_sheet->builder, "varsheet-variable-popup"); + GtkWidget *insert_variable = gtk_menu_item_new_with_mnemonic (_("_Insert Variable")); + GtkWidget *clear_variables = gtk_menu_item_new_with_mnemonic (_("Cl_ear Variables")); + + g_signal_connect_swapped (insert_variable, "activate", G_CALLBACK (psppire_var_sheet_insert_variable), var_sheet); + g_signal_connect_swapped (clear_variables, "activate", G_CALLBACK (psppire_var_sheet_clear_variables), var_sheet); + + gtk_menu_attach (GTK_MENU (menu), insert_variable, 0, 1, i, i + 1); ++i; + gtk_menu_attach (GTK_MENU (menu), clear_variables, 0, 1, i, i + 1); ++i; + + gtk_widget_show_all (menu); + gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, time); } @@ -791,6 +991,7 @@ on_button_pressed (GtkWidget *widget, GdkEventButton *event, return FALSE; } + GType psppire_fmt_use_get_type (void) @@ -817,8 +1018,7 @@ enum PROP_DICTIONARY, PROP_MAY_CREATE_VARS, PROP_MAY_DELETE_VARS, - PROP_FORMAT_TYPE, - PROP_UI_MANAGER + PROP_FORMAT_TYPE }; static void @@ -851,7 +1051,6 @@ psppire_var_sheet_set_property (GObject *object, obj->format_use = g_value_get_enum (value); break; - case PROP_UI_MANAGER: default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -885,30 +1084,12 @@ psppire_var_sheet_get_property (GObject *object, g_value_set_enum (value, obj->format_use); break; - case PROP_UI_MANAGER: - g_value_set_object (value, psppire_var_sheet_get_ui_manager (obj)); - break; - default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } -static void -psppire_var_sheet_realize (GtkWidget *w) -{ - PsppireVarSheet *var_sheet = PSPPIRE_VAR_SHEET (w); - GtkWindow *toplevel; - - GTK_WIDGET_CLASS (psppire_var_sheet_parent_class)->realize (w); - - toplevel = GTK_WINDOW (gtk_widget_get_toplevel (w)); - var_sheet->val_labs_dialog = val_labs_dialog_create (toplevel); - var_sheet->missing_val_dialog = missing_val_dialog_create (toplevel); - var_sheet->var_type_dialog = var_type_dialog_create (toplevel); -} - static void psppire_var_sheet_dispose (GObject *obj) { @@ -928,9 +1109,6 @@ psppire_var_sheet_dispose (GObject *obj) if (var_sheet->dict) g_object_unref (var_sheet->dict); - if (var_sheet->uim) - g_object_unref (var_sheet->uim); - /* These dialogs are not GObjects (although they should be!) But for now, unreffing them only causes a GCritical Error so comment them out for now. (and accept the memory leakage) @@ -947,15 +1125,12 @@ static void psppire_var_sheet_class_init (PsppireVarSheetClass *class) { GObjectClass *gobject_class = G_OBJECT_CLASS (class); - GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class); GParamSpec *pspec; gobject_class->set_property = psppire_var_sheet_set_property; gobject_class->get_property = psppire_var_sheet_get_property; gobject_class->dispose = psppire_var_sheet_dispose; - widget_class->realize = psppire_var_sheet_realize; - g_signal_new ("var-double-clicked", G_OBJECT_CLASS_TYPE (gobject_class), G_SIGNAL_RUN_LAST, @@ -994,13 +1169,6 @@ psppire_var_sheet_class_init (PsppireVarSheetClass *class) FMT_FOR_OUTPUT, G_PARAM_READWRITE); g_object_class_install_property (gobject_class, PROP_FORMAT_TYPE, pspec); - - pspec = g_param_spec_object ("ui-manager", - "UI Manager", - "UI manager for the variable sheet. The client should merge this UI manager with the active UI manager to obtain variable sheet specific menu items and tool bar items.", - GTK_TYPE_UI_MANAGER, - G_PARAM_READABLE); - g_object_class_install_property (gobject_class, PROP_UI_MANAGER, pspec); } static void @@ -1050,6 +1218,16 @@ psppire_var_sheet_row_number_double_clicked (PsppireCellRendererButton *button, gtk_tree_path_free (path); } +static void +psppire_var_sheet_variables_column_clicked (PsppSheetViewColumn *column, + PsppireVarSheet *var_sheet) +{ + PsppSheetView *sheet_view = PSPP_SHEET_VIEW (var_sheet); + PsppSheetSelection *selection = pspp_sheet_view_get_selection (sheet_view); + + pspp_sheet_selection_select_all (selection); +} + static PsppSheetViewColumn * make_row_number_column (PsppireVarSheet *var_sheet) { @@ -1064,22 +1242,26 @@ make_row_number_column (PsppireVarSheet *var_sheet) column = pspp_sheet_view_column_new_with_attributes (_("Variable"), renderer, NULL); + pspp_sheet_view_column_set_clickable (column, TRUE); pspp_sheet_view_column_set_cell_data_func ( column, renderer, render_row_number_cell, var_sheet, NULL); pspp_sheet_view_column_set_fixed_width (column, 50); + g_signal_connect (column, "clicked", + G_CALLBACK (psppire_var_sheet_variables_column_clicked), + var_sheet); + return column; } -static void -on_edit_clear_variables (GtkAction *action, PsppireVarSheet *var_sheet) +void +psppire_var_sheet_clear_variables (PsppireVarSheet *var_sheet) { PsppSheetView *sheet_view = PSPP_SHEET_VIEW (var_sheet); PsppSheetSelection *selection = pspp_sheet_view_get_selection (sheet_view); PsppireDict *dict = var_sheet->dict; const struct range_set_node *node; - struct range_set *selected; - - selected = pspp_sheet_selection_get_range_set (selection); + struct range_set *selected = pspp_sheet_selection_get_range_set (selection); + for (node = range_set_last (selected); node != NULL; node = range_set_prev (selected, node)) { @@ -1088,7 +1270,7 @@ on_edit_clear_variables (GtkAction *action, PsppireVarSheet *var_sheet) for (i = 1; i <= range_set_node_get_width (node); i++) { unsigned long row = range_set_node_get_end (node) - i; - if (row >= 0 && row < psppire_dict_get_var_cnt (dict)) + if (row < psppire_dict_get_var_cnt (dict)) psppire_dict_delete_variables (dict, row, 1); } } @@ -1101,17 +1283,17 @@ on_selection_changed (PsppSheetSelection *selection, { PsppSheetView *sheet_view = pspp_sheet_selection_get_tree_view (selection); PsppireVarSheet *var_sheet = PSPPIRE_VAR_SHEET (sheet_view); - gint n_selected_rows; + gint n_selected_rows = pspp_sheet_selection_count_selected_rows (selection); gboolean may_delete; GtkTreePath *path; - GtkAction *action; - - n_selected_rows = pspp_sheet_selection_count_selected_rows (selection); - - action = get_action_assert (var_sheet->builder, "edit_insert-variable"); - gtk_action_set_sensitive (action, (var_sheet->may_create_vars - && n_selected_rows > 0)); + GtkWidget *top = gtk_widget_get_toplevel (GTK_WIDGET (var_sheet)); + if (! PSPPIRE_IS_DATA_WINDOW (top)) + return; + + PsppireDataWindow *dw = PSPPIRE_DATA_WINDOW (top); + gtk_widget_set_sensitive (dw->mi_insert_var, n_selected_rows > 0); + switch (n_selected_rows) { case 0: @@ -1130,12 +1312,12 @@ on_selection_changed (PsppSheetSelection *selection, may_delete = TRUE; break; } - action = get_action_assert (var_sheet->builder, "edit_clear-variables"); - gtk_action_set_sensitive (action, var_sheet->may_delete_vars && may_delete); + + gtk_widget_set_sensitive (dw->mi_clear_variables, var_sheet->may_delete_vars && may_delete); } -static void -on_edit_insert_variable (GtkAction *action, PsppireVarSheet *var_sheet) +void +psppire_var_sheet_insert_variable (PsppireVarSheet *var_sheet) { PsppSheetView *sheet_view = PSPP_SHEET_VIEW (var_sheet); PsppSheetSelection *selection = pspp_sheet_view_get_selection (sheet_view); @@ -1160,11 +1342,10 @@ psppire_var_sheet_init (PsppireVarSheet *obj) { PsppSheetView *sheet_view = PSPP_SHEET_VIEW (obj); PsppSheetViewColumn *column; - GtkAction *action; GList *list; obj->dict = NULL; - obj->format_use = PSPPIRE_TYPE_FMT_USE; + obj->format_use = FMT_FOR_OUTPUT; obj->may_create_vars = TRUE; obj->may_delete_vars = TRUE; @@ -1172,7 +1353,6 @@ psppire_var_sheet_init (PsppireVarSheet *obj) obj->container = NULL; obj->dispose_has_run = FALSE; - obj->uim = NULL; pspp_sheet_view_append_column (sheet_view, make_row_number_column (obj)); @@ -1199,18 +1379,27 @@ psppire_var_sheet_init (PsppireVarSheet *obj) add_spin_column (obj, VS_COLUMNS, _("Columns"), 3); - add_combo_column (obj, VS_ALIGN, _("Align"), 6, + add_combo_column (obj, VS_ALIGN, _("Align"), 8, alignment_to_stock_id, alignment_to_string (ALIGN_LEFT), ALIGN_LEFT, alignment_to_string (ALIGN_CENTRE), ALIGN_CENTRE, alignment_to_string (ALIGN_RIGHT), ALIGN_RIGHT, NULL); - add_combo_column (obj, VS_MEASURE, _("Measure"), 10, + add_combo_column (obj, VS_MEASURE, _("Measure"), 11, measure_to_stock_id, measure_to_string (MEASURE_NOMINAL), MEASURE_NOMINAL, measure_to_string (MEASURE_ORDINAL), MEASURE_ORDINAL, measure_to_string (MEASURE_SCALE), MEASURE_SCALE, NULL); + add_combo_column (obj, VS_ROLE, _("Role"), 11, role_to_stock_id, + var_role_to_string (ROLE_INPUT), ROLE_INPUT, + var_role_to_string (ROLE_TARGET), ROLE_TARGET, + var_role_to_string (ROLE_BOTH), ROLE_BOTH, + var_role_to_string (ROLE_NONE), ROLE_NONE, + var_role_to_string (ROLE_PARTITION), ROLE_PARTITION, + var_role_to_string (ROLE_SPLIT), ROLE_SPLIT, + NULL); + pspp_sheet_view_set_rubber_banding (sheet_view, TRUE); pspp_sheet_selection_set_mode (pspp_sheet_view_get_selection (sheet_view), PSPP_SHEET_SELECTION_MULTIPLE); @@ -1220,21 +1409,11 @@ psppire_var_sheet_init (PsppireVarSheet *obj) G_CALLBACK (on_query_var_tooltip), NULL); g_signal_connect (obj, "button-press-event", G_CALLBACK (on_button_pressed), NULL); + g_signal_connect (obj, "popup-menu", G_CALLBACK (on_popup_menu), NULL); - obj->builder = builder_new ("var-sheet.ui"); - - action = get_action_assert (obj->builder, "edit_clear-variables"); - g_signal_connect (action, "activate", G_CALLBACK (on_edit_clear_variables), - obj); - gtk_action_set_sensitive (action, FALSE); g_signal_connect (pspp_sheet_view_get_selection (sheet_view), "changed", G_CALLBACK (on_selection_changed), NULL); - - action = get_action_assert (obj->builder, "edit_insert-variable"); - gtk_action_set_sensitive (action, FALSE); - g_signal_connect (action, "activate", G_CALLBACK (on_edit_insert_variable), - obj); } GtkWidget * @@ -1269,7 +1448,9 @@ refresh_model (PsppireVarSheet *var_sheet) } static void -on_var_changed (PsppireDict *dict, glong row, PsppireVarSheet *var_sheet) +on_var_changed (PsppireDict *dict, glong row, + guint what, const struct variable *oldvar, + PsppireVarSheet *var_sheet) { PsppireEmptyListStore *store; @@ -1438,17 +1619,4 @@ psppire_var_sheet_goto_variable (PsppireVarSheet *var_sheet, int dict_index) gtk_tree_path_free (path); } -GtkUIManager * -psppire_var_sheet_get_ui_manager (PsppireVarSheet *var_sheet) -{ - if (var_sheet->uim == NULL) - { - var_sheet->uim = GTK_UI_MANAGER (get_object_assert (var_sheet->builder, - "var_sheet_uim", - GTK_TYPE_UI_MANAGER)); - g_object_ref (var_sheet->uim); - } - - return var_sheet->uim; -}