/* PSPPIRE - a graphical user interface for PSPP.
- Copyright (C) 2011, 2012 Free Software Foundation, Inc.
+ Copyright (C) 2011, 2012, 2013 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
static gboolean pspp_sheet_view_real_select_all (PsppSheetView *tree_view);
static gboolean pspp_sheet_view_real_unselect_all (PsppSheetView *tree_view);
static gboolean pspp_sheet_view_real_select_cursor_row (PsppSheetView *tree_view,
- gboolean start_editing);
+ gboolean start_editing,
+ PsppSheetSelectMode mode);
static gboolean pspp_sheet_view_real_toggle_cursor_row (PsppSheetView *tree_view);
static void pspp_sheet_view_row_changed (GtkTreeModel *model,
GtkTreePath *path,
GdkEventMotion *event);
static void pspp_sheet_view_focus_to_cursor (PsppSheetView *tree_view);
static gboolean pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view,
- gint count);
+ gint count,
+ PsppSheetSelectMode mode);
static void pspp_sheet_view_move_cursor_page_up_down (PsppSheetView *tree_view,
- gint count);
+ gint count,
+ PsppSheetSelectMode mode);
static void pspp_sheet_view_move_cursor_left_right (PsppSheetView *tree_view,
- gint count);
+ gint count,
+ PsppSheetSelectMode mode);
+static void pspp_sheet_view_move_cursor_line_start_end (PsppSheetView *tree_view,
+ gint count,
+ PsppSheetSelectMode mode);
static void pspp_sheet_view_move_cursor_tab (PsppSheetView *tree_view,
gint count);
static void pspp_sheet_view_move_cursor_start_end (PsppSheetView *tree_view,
- gint count);
+ gint count,
+ PsppSheetSelectMode mode);
static void pspp_sheet_view_real_set_cursor (PsppSheetView *tree_view,
GtkTreePath *path,
gboolean clear_and_select,
- gboolean clamp_node);
+ gboolean clamp_node,
+ PsppSheetSelectMode mode);
static gboolean pspp_sheet_view_has_special_cell (PsppSheetView *tree_view);
static void pspp_sheet_view_stop_rubber_band (PsppSheetView *tree_view);
static void update_prelight (PsppSheetView *tree_view,
G_STRUCT_OFFSET (PsppSheetViewClass, select_cursor_row),
NULL, NULL,
psppire_marshal_BOOLEAN__BOOLEAN,
- G_TYPE_BOOLEAN, 1,
- G_TYPE_BOOLEAN);
+ G_TYPE_BOOLEAN, 2,
+ G_TYPE_BOOLEAN, G_TYPE_INT);
tree_view_signals[TOGGLE_CURSOR_ROW] =
g_signal_new ("toggle-cursor-row",
GTK_MOVEMENT_DISPLAY_LINES, 1);
pspp_sheet_view_add_move_binding (binding_set[i], GDK_Home, 0, TRUE,
- GTK_MOVEMENT_BUFFER_ENDS, -1);
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Home, 0, TRUE,
- GTK_MOVEMENT_BUFFER_ENDS, -1);
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
pspp_sheet_view_add_move_binding (binding_set[i], GDK_End, 0, TRUE,
- GTK_MOVEMENT_BUFFER_ENDS, 1);
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_End, 0, TRUE,
- GTK_MOVEMENT_BUFFER_ENDS, 1);
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
pspp_sheet_view_add_move_binding (binding_set[i], GDK_Page_Up, 0, TRUE,
GTK_MOVEMENT_PAGES, -1);
GTK_MOVEMENT_PAGES, 1);
+ gtk_binding_entry_add_signal (binding_set[i], GDK_Up, GDK_CONTROL_MASK, "move-cursor", 2,
+ G_TYPE_ENUM, GTK_MOVEMENT_BUFFER_ENDS,
+ G_TYPE_INT, -1);
+
+ gtk_binding_entry_add_signal (binding_set[i], GDK_Down, GDK_CONTROL_MASK, "move-cursor", 2,
+ G_TYPE_ENUM, GTK_MOVEMENT_BUFFER_ENDS,
+ G_TYPE_INT, 1);
+
gtk_binding_entry_add_signal (binding_set[i], GDK_Right, 0, "move-cursor", 2,
G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
G_TYPE_INT, 1);
G_TYPE_INT, -1);
gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Right, 0, "move-cursor", 2,
- G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS,
G_TYPE_INT, 1);
gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Left, 0, "move-cursor", 2,
- G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS,
G_TYPE_INT, -1);
gtk_binding_entry_add_signal (binding_set[i], GDK_Right, GDK_CONTROL_MASK,
"move-cursor", 2,
- G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS,
G_TYPE_INT, 1);
gtk_binding_entry_add_signal (binding_set[i], GDK_Left, GDK_CONTROL_MASK,
"move-cursor", 2,
- G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS,
G_TYPE_INT, -1);
gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Right, GDK_CONTROL_MASK,
gtk_binding_entry_add_signal (binding_set[0], GDK_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
gtk_binding_entry_add_signal (binding_set[0], GDK_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
- G_TYPE_BOOLEAN, TRUE);
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_INT, PSPP_SHEET_SELECT_MODE_EXTEND);
gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
- G_TYPE_BOOLEAN, TRUE);
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_INT, PSPP_SHEET_SELECT_MODE_EXTEND);
gtk_binding_entry_add_signal (binding_set[0], GDK_space, 0, "select-cursor-row", 1,
- G_TYPE_BOOLEAN, TRUE);
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_INT, 0);
gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Space, 0, "select-cursor-row", 1,
- G_TYPE_BOOLEAN, TRUE);
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_INT, 0);
gtk_binding_entry_add_signal (binding_set[0], GDK_Return, 0, "select-cursor-row", 1,
- G_TYPE_BOOLEAN, TRUE);
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_INT, 0);
gtk_binding_entry_add_signal (binding_set[0], GDK_ISO_Enter, 0, "select-cursor-row", 1,
- G_TYPE_BOOLEAN, TRUE);
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_INT, 0);
gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Enter, 0, "select-cursor-row", 1,
- G_TYPE_BOOLEAN, TRUE);
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_INT, 0);
gtk_binding_entry_add_signal (binding_set[0], GDK_BackSpace, 0, "select-cursor-parent", 0);
gtk_binding_entry_add_signal (binding_set[0], GDK_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
pspp_sheet_view_map_buttons (tree_view);
- gdk_window_show (widget->window);
+ gdk_window_show (gtk_widget_get_window (widget));
}
static void
pspp_sheet_view_realize (GtkWidget *widget)
{
- gint i;
PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
GList *tmp_list;
GdkWindowAttr attributes;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
- &attributes, attributes_mask);
- gdk_window_set_user_data (widget->window, widget);
+ gtk_widget_set_window (widget,
+ gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes, attributes_mask));
+ gdk_window_set_user_data (gtk_widget_get_window (widget), widget);
/* Make the window for the tree */
attributes.x = 0;
GDK_BUTTON_RELEASE_MASK |
gtk_widget_get_events (widget));
- tree_view->priv->bin_window = gdk_window_new (widget->window,
+ tree_view->priv->bin_window = gdk_window_new (gtk_widget_get_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (tree_view->priv->bin_window, widget);
GDK_KEY_RELEASE_MASK |
gtk_widget_get_events (widget));
- tree_view->priv->header_window = gdk_window_new (widget->window,
+ tree_view->priv->header_window = gdk_window_new (gtk_widget_get_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (tree_view->priv->header_window, widget);
/* Add them all up. */
- widget->style = gtk_style_attach (widget->style, widget->window);
- gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
+ widget->style = gtk_style_attach (widget->style, gtk_widget_get_window (widget));
+ gdk_window_set_back_pixmap (gtk_widget_get_window (widget), NULL, FALSE);
gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL);
pspp_sheet_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
install_presize_handler (tree_view);
-
- for (i = 0; i < 5; ++i)
- {
- tree_view->priv->grid_line_gc[i] = gdk_gc_new (widget->window);
- gdk_gc_copy (tree_view->priv->grid_line_gc[i], widget->style->text_aa_gc[i]);
- }
}
static void
pspp_sheet_view_unrealize (GtkWidget *widget)
{
- gint x;
PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
PsppSheetViewPrivate *priv = tree_view->priv;
GList *list;
priv->drag_highlight_window = NULL;
}
- for (x = 0 ; x < 5 ; ++x)
- g_object_unref (priv->grid_line_gc[x]);
-
if (tree_view->priv->columns != NULL)
{
list = tree_view->priv->columns;
invalid_rect.width = column->width;
invalid_rect.height = widget->allocation.height;
- gdk_window_invalidate_rect (widget->window, &invalid_rect, TRUE);
+ gdk_window_invalidate_rect (gtk_widget_get_window (widget), &invalid_rect, TRUE);
break;
}
if (column == tree_view->priv->drag_column)
{
GtkAllocation drag_allocation;
- gdk_drawable_get_size (tree_view->priv->drag_window,
- &(drag_allocation.width),
- &(drag_allocation.height));
+ drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
+ drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
drag_allocation.x = 0;
drag_allocation.y = 0;
pspp_sheet_view_column_size_allocate (tree_view->priv->drag_column,
if (gtk_widget_get_realized (widget))
{
- gdk_window_move_resize (widget->window,
+ gdk_window_move_resize (gtk_widget_get_window (widget),
allocation->x, allocation->y,
allocation->width, allocation->height);
gdk_window_move_resize (tree_view->priv->header_window,
*/
if (event->type == GDK_BUTTON_PRESS)
{
+ PsppSheetSelectionMode mode = 0;
+
if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
- tree_view->priv->ctrl_pressed = TRUE;
+ mode |= PSPP_SHEET_SELECT_MODE_TOGGLE;
if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
- tree_view->priv->shift_pressed = TRUE;
+ mode |= PSPP_SHEET_SELECT_MODE_EXTEND;
focus_cell = _pspp_sheet_view_column_get_cell_at_pos (column, event->x - background_area.x);
if (focus_cell)
if (event->state & GDK_CONTROL_MASK)
{
- pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE, mode);
pspp_sheet_view_real_toggle_cursor_row (tree_view);
}
else if (event->state & GDK_SHIFT_MASK)
{
- pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE);
- pspp_sheet_view_real_select_cursor_row (tree_view, FALSE);
+ pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, mode);
+ pspp_sheet_view_real_select_cursor_row (tree_view, FALSE, mode);
}
else
{
- pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, 0);
}
if (tree_view->priv->anchor_column == NULL ||
pspp_sheet_selection_select_column_range (tree_view->priv->selection,
tree_view->priv->anchor_column,
column);
-
- tree_view->priv->ctrl_pressed = FALSE;
- tree_view->priv->shift_pressed = FALSE;
}
/* the treeview may have been scrolled because of _set_cursor,
PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE);
gtk_grab_remove (widget);
- gdk_display_pointer_ungrab (gdk_drawable_get_display (event->window),
+ gdk_display_pointer_ungrab (gdk_window_get_display (event->window),
event->time);
return TRUE;
}
return FALSE;
pspp_sheet_view_real_set_cursor (tree_view, path,
- TRUE, TRUE);
+ TRUE, TRUE, 0); /* XXX mode? */
gtk_widget_queue_draw (GTK_WIDGET (tree_view));
area = cell_area;
if (pspp_sheet_view_node_is_selected (tree_view, node))
{
PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
- pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, FALSE);
+ pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, FALSE, 0); /* XXX mode? */
}
gtk_tree_path_free (path);
}
static void
pspp_sheet_view_motion_draw_column_motion_arrow (PsppSheetView *tree_view)
{
+#if GTK3_TRANSITION
PsppSheetViewColumnReorder *reorder = tree_view->priv->cur_reorder;
GtkWidget *widget = GTK_WIDGET (tree_view);
GdkBitmap *mask = NULL;
/* Get x, y, width, height of arrow */
width = width/2; /* remember, the arrow only takes half the available width */
- gdk_window_get_origin (widget->window, &x, &y);
+ gdk_window_get_origin (gtk_widget_get_window (widget), &x, &y);
if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
x += widget->allocation.width - width;
gdk_window_show (tree_view->priv->drag_highlight_window);
gdk_window_raise (tree_view->priv->drag_highlight_window);
+#endif
}
static gboolean
column = pspp_sheet_view_get_column (tree_view, tree_view->priv->drag_pos);
- if (event->is_hint || event->window != widget->window)
+ if (event->is_hint || event->window != gtk_widget_get_window (widget))
gtk_widget_get_pointer (widget, &x, NULL);
else
x = event->x;
/* ... and the cursor to the end path */
tmp_path = _pspp_sheet_view_find_path (tree_view,
tree_view->priv->rubber_band_end_node);
- pspp_sheet_view_real_set_cursor (PSPP_SHEET_VIEW (tree_view), tmp_path, FALSE, FALSE);
+ pspp_sheet_view_real_set_cursor (PSPP_SHEET_VIEW (tree_view), tmp_path, FALSE, FALSE, 0); /* XXX mode? */
gtk_tree_path_free (tmp_path);
_pspp_sheet_selection_emit_changed (tree_view->priv->selection);
area.x = 0;
area.y = 0;
- gdk_drawable_get_size (tree_view->priv->bin_window, &area.width, &area.height);
+ area.width = gdk_window_get_width (tree_view->priv->bin_window);
+ area.height = gdk_window_get_height (tree_view->priv->bin_window);
gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
}
if (!gtk_widget_has_focus (widget))
return;
- gdk_drawable_get_size (tree_view->priv->bin_window, &w, &h);
+ w = gdk_window_get_width (tree_view->priv->bin_window);
+ h = gdk_window_get_height (tree_view->priv->bin_window);
w -= 2;
h -= 2;
}
static void
-pspp_sheet_view_draw_grid_lines (PsppSheetView *tree_view,
+pspp_sheet_view_draw_vertical_grid_lines (PsppSheetView *tree_view,
GdkEventExpose *event,
gint n_visible_columns,
gint min_y,
GList *list = tree_view->priv->columns;
gint i = 0;
gint current_x = 0;
- gint height;
if (tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_VERTICAL
&& tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_BOTH)
return;
- gdk_drawable_get_size (event->window, NULL, &height);
-
/* Only draw the lines for visible rows and columns */
for (list = tree_view->priv->columns; list; list = list->next, i++)
{
if (current_x - 1 >= event->area.x
&& current_x - 1 < event->area.x + event->area.width)
- gdk_draw_line (event->window,
- tree_view->priv->grid_line_gc[GTK_WIDGET(tree_view)->state],
- current_x - 1, min_y,
- current_x - 1, max_y - min_y);
+ {
+#if GTK3_TRANSITION
+ gdk_draw_line (event->window,
+ tree_view->priv->grid_line_gc[GTK_WIDGET(tree_view)->state],
+ current_x - 1, min_y,
+ current_x - 1, max_y - min_y);
+#else
+
+ cairo_t *cr = gdk_cairo_create (event->window);
+ cairo_set_line_width (cr, 1.0);
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+ cairo_move_to (cr, current_x - 0.5, min_y);
+ cairo_line_to (cr, current_x - 0.5 , max_y - min_y);
+
+ cairo_stroke (cr);
+ cairo_destroy (cr);
+#endif
+ }
}
}
*/
static gboolean
pspp_sheet_view_bin_expose (GtkWidget *widget,
- GdkEventExpose *event)
+ GdkEventExpose *event)
{
PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
GtkTreePath *path;
}
/* clip event->area to the visible area */
- if (event->area.height < 0)
+ if (event->area.height < 0.5)
return TRUE;
validate_visible_area (tree_view);
if (new_y < 0)
new_y = 0;
y_offset = -pspp_sheet_view_find_offset (tree_view, new_y, &node);
- gdk_drawable_get_size (tree_view->priv->bin_window,
- &bin_window_width, &bin_window_height);
+ bin_window_width =
+ gdk_window_get_width (tree_view->priv->bin_window);
+
+ bin_window_height =
+ gdk_window_get_height (tree_view->priv->bin_window);
+
if (tree_view->priv->height < bin_window_height)
{
if (draw_hgrid_lines)
{
- if (background_area.y > 0)
- gdk_draw_line (event->window,
- tree_view->priv->grid_line_gc[widget->state],
- background_area.x, background_area.y,
- background_area.x + background_area.width,
- background_area.y);
-
- if (y_offset + max_height >= event->area.height)
- gdk_draw_line (event->window,
- tree_view->priv->grid_line_gc[widget->state],
- background_area.x, background_area.y + max_height,
- background_area.x + background_area.width,
- background_area.y + max_height);
+ cairo_t *cr = gdk_cairo_create (event->window);
+ cairo_set_line_width (cr, 1.0);
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+
+ if (background_area.y >= 0)
+ {
+#if GTK3_TRANSITION
+ gdk_draw_line (event->window,
+ tree_view->priv->grid_line_gc[widget->state],
+ background_area.x, background_area.y,
+ background_area.x + background_area.width,
+ background_area.y);
+#else
+ cairo_move_to (cr, background_area.x, background_area.y - 0.5);
+ cairo_line_to (cr, background_area.x + background_area.width,
+ background_area.y - 0.5);
+#endif
+ }
+
+ if (y_offset + max_height >= event->area.height - 0.5)
+ {
+#if GTK3_TRANSITION
+ gdk_draw_line (event->window,
+ tree_view->priv->grid_line_gc[widget->state],
+ background_area.x, background_area.y + max_height,
+ background_area.x + background_area.width,
+ background_area.y + max_height);
+#else
+
+ cairo_move_to (cr, background_area.x, background_area.y + max_height - 0.5);
+ cairo_line_to (cr, background_area.x + background_area.width,
+ background_area.y + max_height - 0.5);
+#endif
+ }
+ cairo_stroke (cr);
+ cairo_destroy (cr);
}
_pspp_sheet_view_column_cell_render (column,
if (node < 0)
break;
- gdk_drawable_get_size (tree_view->priv->bin_window,
- &width, NULL);
+ width = gdk_window_get_width (tree_view->priv->bin_window);
if (row_ending_details)
gtk_paint_focus (widget->style,
break;
}
+#if GTK3_TRANSITION
if (highlight_y >= 0)
{
gdk_draw_line (event->window,
rtl ? 0 : bin_window_width,
highlight_y);
}
+#endif
}
/* draw the big row-spanning focus rectangle, if needed */
(flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE :
GTK_STATE_NORMAL));
- gdk_drawable_get_size (tree_view->priv->bin_window,
- &width, NULL);
+ width = gdk_window_get_width (tree_view->priv->bin_window);
if (draw_hgrid_lines)
{
while (y_offset < event->area.height);
done:
- pspp_sheet_view_draw_grid_lines (tree_view, event, n_visible_columns,
+ pspp_sheet_view_draw_vertical_grid_lines (tree_view, event, n_visible_columns,
min_y, max_y);
if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
continue;
n_visible_columns ++;
}
- pspp_sheet_view_draw_grid_lines (tree_view,
+ pspp_sheet_view_draw_vertical_grid_lines (tree_view,
event,
n_visible_columns,
event->area.y,
if (!focus_column->button)
{
pspp_sheet_view_column_set_need_button (focus_column, TRUE);
- g_return_if_fail (focus_column->button != NULL);
+ // g_return_if_fail (focus_column->button != NULL);
+ if (focus_column->button == NULL)
+ return;
}
if (GTK_CONTAINER (tree_view)->focus_child != focus_column->button)
if (gtk_widget_get_realized (widget))
{
- gint i;
- PsppSheetViewPrivate *priv = PSPP_SHEET_VIEW (widget)->priv;
-
- gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
+ gdk_window_set_back_pixmap (gtk_widget_get_window (widget), NULL, FALSE);
gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL);
- for (i = 0; i < 5 ; ++i)
- {
- g_object_unref (priv->grid_line_gc[i]);
- priv->grid_line_gc[i] = gdk_gc_new (widget->window);
- gdk_gc_copy (priv->grid_line_gc[i], widget->style->text_aa_gc[i]);
- }
-
pspp_sheet_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
}
GtkMovementStep step,
gint count)
{
+ PsppSheetSelectMode mode;
GdkModifierType state;
g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
step == GTK_MOVEMENT_VISUAL_POSITIONS ||
step == GTK_MOVEMENT_DISPLAY_LINES ||
step == GTK_MOVEMENT_PAGES ||
- step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
+ step == GTK_MOVEMENT_BUFFER_ENDS ||
+ step == GTK_MOVEMENT_DISPLAY_LINE_ENDS, FALSE);
if (tree_view->priv->row_count == 0)
return FALSE;
PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+ mode = 0;
if (gtk_get_current_event_state (&state))
{
if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
- tree_view->priv->ctrl_pressed = TRUE;
+ mode |= PSPP_SHEET_SELECT_MODE_TOGGLE;
if ((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
- tree_view->priv->shift_pressed = TRUE;
+ mode |= PSPP_SHEET_SELECT_MODE_EXTEND;
}
/* else we assume not pressed */
pspp_sheet_view_move_cursor_tab (tree_view, count);
break;
case GTK_MOVEMENT_VISUAL_POSITIONS:
- pspp_sheet_view_move_cursor_left_right (tree_view, count);
+ pspp_sheet_view_move_cursor_left_right (tree_view, count, mode);
break;
case GTK_MOVEMENT_DISPLAY_LINES:
- pspp_sheet_view_move_cursor_up_down (tree_view, count);
+ pspp_sheet_view_move_cursor_up_down (tree_view, count, mode);
break;
case GTK_MOVEMENT_PAGES:
- pspp_sheet_view_move_cursor_page_up_down (tree_view, count);
+ pspp_sheet_view_move_cursor_page_up_down (tree_view, count, mode);
break;
case GTK_MOVEMENT_BUFFER_ENDS:
- pspp_sheet_view_move_cursor_start_end (tree_view, count);
+ pspp_sheet_view_move_cursor_start_end (tree_view, count, mode);
+ break;
+ case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
+ pspp_sheet_view_move_cursor_line_start_end (tree_view, count, mode);
break;
default:
g_assert_not_reached ();
}
- tree_view->priv->ctrl_pressed = FALSE;
- tree_view->priv->shift_pressed = FALSE;
-
return TRUE;
}
}
else
{
- gint width;
-
- gdk_drawable_get_size (tree_view->priv->header_window, &width, NULL);
+ gint width = gdk_window_get_width (tree_view->priv->header_window);
reorder->right_align = width + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
}
}
{
GdkEvent *send_event;
GtkAllocation allocation;
- gint x, y, width, height;
+ gint x, y;
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
GdkDisplay *display = gdk_screen_get_display (screen);
gdk_window_show (tree_view->priv->drag_window);
gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
- gdk_drawable_get_size (tree_view->priv->header_window, &width, &height);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
while (gtk_events_pending ())
{
if (tree_view->priv->selection->type == PSPP_SHEET_SELECTION_MULTIPLE ||
tree_view->priv->selection->type == PSPP_SHEET_SELECTION_RECTANGLE)
- pspp_sheet_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
+ pspp_sheet_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE, 0);
else
- pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
+ pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE, 0);
}
}
static gboolean
pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view,
- gint count)
+ gint count,
+ PsppSheetSelectMode mode)
{
gint selection_count;
int cursor_node = -1;
if (selection_count == 0
&& tree_view->priv->selection->type != PSPP_SHEET_SELECTION_NONE
- && !tree_view->priv->ctrl_pressed)
+ && !(mode & PSPP_SHEET_SELECT_MODE_TOGGLE))
{
/* Don't move the cursor, but just select the current node */
new_cursor_node = cursor_node;
if (new_cursor_node >= 0)
{
cursor_path = _pspp_sheet_view_find_path (tree_view, new_cursor_node);
- pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
+ pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE, mode);
gtk_tree_path_free (cursor_path);
}
else
{
pspp_sheet_view_clamp_node_visible (tree_view, cursor_node);
- if (!tree_view->priv->shift_pressed)
+ if (!(mode & PSPP_SHEET_SELECT_MODE_EXTEND))
{
if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
count < 0 ?
static void
pspp_sheet_view_move_cursor_page_up_down (PsppSheetView *tree_view,
- gint count)
+ gint count,
+ PsppSheetSelectMode mode)
{
int cursor_node = -1;
GtkTreePath *old_cursor_path = NULL;
/* update y */
y = pspp_sheet_view_node_find_offset (tree_view, cursor_node);
- pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
+ pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE, mode);
y -= window_y;
pspp_sheet_view_scroll_to_point (tree_view, -1, y);
static void
pspp_sheet_view_move_cursor_left_right (PsppSheetView *tree_view,
- gint count)
+ gint count,
+ PsppSheetSelectMode mode)
{
int cursor_node = -1;
GtkTreePath *cursor_path = NULL;
tree_view->priv->focus_column, TRUE);
}
+static void
+pspp_sheet_view_move_cursor_line_start_end (PsppSheetView *tree_view,
+ gint count,
+ PsppSheetSelectMode mode)
+{
+ int cursor_node = -1;
+ GtkTreePath *cursor_path = NULL;
+ PsppSheetViewColumn *column;
+ PsppSheetViewColumn *found_column;
+ GtkTreeIter iter;
+ GList *list;
+ gboolean rtl;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
+
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return;
+
+ if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ else
+ return;
+
+ _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_node);
+ if (cursor_node < 0)
+ return;
+ if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
+ {
+ gtk_tree_path_free (cursor_path);
+ return;
+ }
+ gtk_tree_path_free (cursor_path);
+
+ list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
+ if (tree_view->priv->focus_column)
+ {
+ for (; list; list = (rtl ? list->prev : list->next))
+ {
+ if (list->data == tree_view->priv->focus_column)
+ break;
+ }
+ }
+
+ found_column = NULL;
+ while (list)
+ {
+ gboolean left, right;
+
+ column = list->data;
+ if (column->visible == FALSE || column->row_head)
+ goto loop_end;
+
+ pspp_sheet_view_column_cell_set_cell_data (column,
+ tree_view->priv->model,
+ &iter);
+
+ if (rtl)
+ {
+ right = list->prev ? TRUE : FALSE;
+ left = list->next ? TRUE : FALSE;
+ }
+ else
+ {
+ left = list->prev ? TRUE : FALSE;
+ right = list->next ? TRUE : FALSE;
+ }
+
+ if (column->tabbable
+ && _pspp_sheet_view_column_cell_focus (column, count, left, right))
+ found_column = column;
+
+ loop_end:
+ if (count == 1)
+ list = rtl ? list->prev : list->next;
+ else
+ list = rtl ? list->next : list->prev;
+ }
+
+ if (found_column)
+ {
+ tree_view->priv->focus_column = found_column;
+ _pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL);
+ g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+ }
+
+ pspp_sheet_view_clamp_column_visible (tree_view,
+ tree_view->priv->focus_column, TRUE);
+}
+
static gboolean
try_move_cursor_tab (PsppSheetView *tree_view,
gboolean start_at_focus_column,
if (!try_move_cursor_tab (tree_view, TRUE, count))
{
- /* Shift+Tab goes backward, but Shift isn't supposed to act as Shift does
- for other movement commands, that is, it shouldn't cause the selection
- to be extended, so we need to act as though it is off. */
- tree_view->priv->shift_pressed = FALSE;
-
- if (pspp_sheet_view_move_cursor_up_down (tree_view, count)
+ if (pspp_sheet_view_move_cursor_up_down (tree_view, count, 0)
&& !try_move_cursor_tab (tree_view, FALSE, count))
gtk_widget_error_bell (GTK_WIDGET (tree_view));
}
static void
pspp_sheet_view_move_cursor_start_end (PsppSheetView *tree_view,
- gint count)
+ gint count,
+ PsppSheetSelectMode mode)
{
int cursor_node;
GtkTreePath *path;
if (gtk_tree_path_compare (old_path, path))
{
- pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, mode);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
}
else
static gboolean
pspp_sheet_view_real_select_cursor_row (PsppSheetView *tree_view,
- gboolean start_editing)
+ gboolean start_editing,
+ PsppSheetSelectMode mode)
{
int new_node = -1;
int cursor_node = -1;
GtkTreePath *cursor_path = NULL;
- GtkTreeSelectMode mode = 0;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
return FALSE;
}
- if (!tree_view->priv->shift_pressed && start_editing &&
+ if (!(mode & PSPP_SHEET_SELECT_MODE_EXTEND) && start_editing &&
tree_view->priv->focus_column)
{
if (pspp_sheet_view_start_editing (tree_view, cursor_path))
}
}
- if (tree_view->priv->ctrl_pressed)
- mode |= GTK_TREE_SELECT_MODE_TOGGLE;
- if (tree_view->priv->shift_pressed)
- mode |= GTK_TREE_SELECT_MODE_EXTEND;
-
_pspp_sheet_selection_internal_select_node (tree_view->priv->selection,
cursor_node,
cursor_path,
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
_pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL);
- if (!tree_view->priv->shift_pressed)
+ if (!(mode & PSPP_SHEET_SELECT_MODE_EXTEND))
pspp_sheet_view_row_activated (tree_view, cursor_path,
tree_view->priv->focus_column);
_pspp_sheet_selection_internal_select_node (tree_view->priv->selection,
cursor_node,
cursor_path,
- GTK_TREE_SELECT_MODE_TOGGLE,
+ PSPP_SHEET_SELECT_MODE_TOGGLE,
FALSE);
/* We bail out if the original (tree, node) don't exist anymore after
{
GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
- g_object_ref (widget);
-
- if (in)
- GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
- else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
-
fevent->focus_change.type = GDK_FOCUS_CHANGE;
- fevent->focus_change.window = g_object_ref (widget->window);
+ fevent->focus_change.window = g_object_ref (gtk_widget_get_window (widget));
fevent->focus_change.in = in;
- gtk_widget_event (widget, fevent);
-
- g_object_notify (G_OBJECT (widget), "has-focus");
-
- g_object_unref (widget);
+ gtk_widget_send_focus_change (widget, fevent);
gdk_event_free (fevent);
}
gint width;
gboolean rtl;
- /* first translate the x position from widget->window
+ /* first translate the x position from gtk_widget_get_window (widget)
* to clist->clist_window
*/
rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
int dy;
} ScrollData;
-/* The window to which widget->window is relative */
+/* The window to which gtk_widget_get_window (widget) is relative */
#define ALLOCATION_WINDOW(widget) \
(!gtk_widget_get_has_window (widget) ? \
(widget)->window : \
pspp_sheet_view_real_set_cursor (PsppSheetView *tree_view,
GtkTreePath *path,
gboolean clear_and_select,
- gboolean clamp_node)
+ gboolean clamp_node,
+ PsppSheetSelectMode mode)
{
int node = -1;
{
int new_node = -1;
- if (clear_and_select && !tree_view->priv->ctrl_pressed)
- {
- GtkTreeSelectMode mode = 0;
-
- if (tree_view->priv->ctrl_pressed)
- mode |= GTK_TREE_SELECT_MODE_TOGGLE;
- if (tree_view->priv->shift_pressed)
- mode |= GTK_TREE_SELECT_MODE_EXTEND;
-
- _pspp_sheet_selection_internal_select_node (tree_view->priv->selection,
+ if (clear_and_select && !(mode & PSPP_SHEET_SELECT_MODE_TOGGLE))
+ _pspp_sheet_selection_internal_select_node (tree_view->priv->selection,
node, path, mode,
FALSE);
- }
/* We have to re-find tree and node here again, somebody might have
* cleared the node or the whole tree in the PsppSheetSelection::changed
tree_view->priv->edited_column->editable_widget)
pspp_sheet_view_stop_editing (tree_view, TRUE);
- pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, 0);
if (focus_column && focus_column->visible)
{
background_area.y = y;
background_area.height = ROW_HEIGHT (tree_view);
- gdk_drawable_get_size (tree_view->priv->bin_window,
- &bin_window_width, NULL);
+ bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
drawable = gdk_pixmap_new (tree_view->priv->bin_window,
bin_window_width + 2,
expose_area.width = bin_window_width + 2;
expose_area.height = background_area.height + 2;
+#if GTK3_TRANSITION
gdk_draw_rectangle (drawable,
widget->style->base_gc [gtk_widget_get_state (widget)],
TRUE,
0, 0,
bin_window_width + 2,
background_area.height + 2);
+#endif
rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
cell_offset += column->width;
}
+#if GTK3_TRANSITION
gdk_draw_rectangle (drawable,
widget->style->black_gc,
FALSE,
0, 0,
bin_window_width + 1,
background_area.height + 1);
+#endif
return drawable;
}
gint x, y;
gint tree_x, tree_y;
gint tree_width, tree_height;
- GdkWindow *tree_window = GTK_WIDGET (tree_view)->window;
- GdkScreen *screen = gdk_drawable_get_screen (tree_window);
+ GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
+ GdkScreen *screen = gdk_window_get_screen (tree_window);
GtkRequisition requisition;
gint monitor_num;
GdkRectangle monitor;
gtk_widget_realize (search_dialog);
gdk_window_get_origin (tree_window, &tree_x, &tree_y);
- gdk_drawable_get_size (tree_window,
- &tree_width,
- &tree_height);
+ tree_width = gdk_window_get_width (tree_window);
+ tree_height = gdk_window_get_height (tree_window);
+
gtk_widget_size_request (search_dialog, &requisition);
if (tree_x + tree_width > gdk_screen_get_width (screen))
pspp_sheet_view_scroll_to_cell (tree_view, path, NULL,
TRUE, 0.5, 0.0);
pspp_sheet_selection_select_iter (selection, iter);
- pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE, 0);
if (path)
gtk_tree_path_free (path);
}
break;
+ case GDK_CONTROL_MASK:
+ switch (event->keyval)
+ {
+ case GDK_Left: case GDK_KP_Left:
+ if (!is_all_selected (widget) && !is_at_left (widget))
+ return FALSE;
+ break;
+
+ case GDK_Right: case GDK_KP_Right:
+ if (!is_all_selected (widget) && !is_at_right (widget))
+ return FALSE;
+ break;
+
+ case GDK_Up: case GDK_KP_Up:
+ case GDK_Down: case GDK_KP_Down:
+ break;
+
+ default:
+ return FALSE;
+ }
+ break;
+
default:
return FALSE;
}
row = gtk_tree_path_get_indices (path)[0];
tree_view->priv->edited_row = row;
- pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE, 0);
cell_area->y += pre_val - (int)tree_view->priv->vadjustment->value;
pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection);
if (gtk_widget_get_realized (widget))
{
- gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
+ gdk_window_set_back_pixmap (gtk_widget_get_window (widget), NULL, FALSE);
gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
}
return continue_emission;
}
+
GType
pspp_sheet_view_grid_lines_get_type (void)
{
projects / pspp / blobdiff