| blob | 7c80ec0c0284938e0d356d283a01e43e395b780e |
1 /* PSPPIRE - a graphical user interface for PSPP.
2 Copyright (C) 2011, 2012, 2013 Free Software Foundation, Inc.
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.
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.
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/>. */
17 /* gtktreeview.c
18 * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
19 *
20 * This library is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU Library General Public
22 * License as published by the Free Software Foundation; either
23 * version 2 of the License, or (at your option) any later version.
24 *
25 * This library is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
28 * Library General Public License for more details.
29 *
30 * You should have received a copy of the GNU Library General Public
31 * License along with this library; if not, write to the
32 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
33 * Boston, MA 02111-1307, USA.
34 */
36 #include <config.h>
40 #include <gtk/gtk.h>
41 #include <gdk/gdk.h>
42 #include <gdk/gdkkeysyms.h>
43 #include <gdk/gdkkeysyms-compat.h>
44 #include <string.h>
49 #define P_(STRING) STRING
50 #define GTK_PARAM_READABLE G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
51 #define GTK_PARAM_READWRITE G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
53 /* Many keyboard shortcuts for Mac are the same as for X
54 * except they use Command key instead of Control (e.g. Cut,
55 * Copy, Paste). This symbol is for those simple cases. */
56 #ifndef GDK_WINDOWING_QUARTZ
57 #define GTK_DEFAULT_ACCEL_MOD_MASK GDK_CONTROL_MASK
58 #else
59 #define GTK_DEFAULT_ACCEL_MOD_MASK GDK_META_MASK
60 #endif
62 #define PSPP_SHEET_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
63 #define PSPP_SHEET_VIEW_PRIORITY_SCROLL_SYNC (PSPP_SHEET_VIEW_PRIORITY_VALIDATE + 2)
64 #define PSPP_SHEET_VIEW_TIME_MS_PER_IDLE 30
65 #define SCROLL_EDGE_SIZE 15
66 #define EXPANDER_EXTRA_PADDING 4
67 #define PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT 5000
69 /* The "background" areas of all rows/cells add up to cover the entire tree.
70 * The background includes all inter-row and inter-cell spacing.
71 * The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
72 * i.e. just the cells, no spacing.
73 */
75 #define BACKGROUND_HEIGHT(tree_view) (tree_view->priv->fixed_height)
76 #define CELL_HEIGHT(tree_view, separator) ((BACKGROUND_HEIGHT (tree_view)) - (separator))
78 /* Translate from bin_window coordinates to rbtree (tree coordinates) and
79 * vice versa.
80 */
81 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
82 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
84 /* This is in bin_window coordinates */
85 #define BACKGROUND_FIRST_PIXEL(tree_view,node) (RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, pspp_sheet_view_node_find_offset (tree_view, (node))))
86 #define CELL_FIRST_PIXEL(tree_view,node,separator) (BACKGROUND_FIRST_PIXEL (tree_view,node) + separator/2)
88 #define ROW_HEIGHT(tree_view) \
89 ((tree_view->priv->fixed_height > 0) ? (tree_view->priv->fixed_height) : (tree_view)->priv->expander_size)
93 struct _PsppSheetViewChild
94 {
96 gint x;
97 gint y;
98 gint width;
99 gint height;
100 };
104 struct _TreeViewDragInfo
105 {
106 GdkModifierType start_button_mask;
108 GdkDragAction source_actions;
114 };
117 /* Signals */
118 enum
119 {
120 ROW_ACTIVATED,
121 COLUMNS_CHANGED,
122 CURSOR_CHANGED,
123 MOVE_CURSOR,
124 SELECT_ALL,
125 UNSELECT_ALL,
126 SELECT_CURSOR_ROW,
127 TOGGLE_CURSOR_ROW,
128 START_INTERACTIVE_SEARCH,
129 LAST_SIGNAL
130 };
132 /* Properties */
134 PROP_0,
135 PROP_MODEL,
136 PROP_HADJUSTMENT,
137 PROP_VADJUSTMENT,
138 PROP_HSCROLL_POLICY,
139 PROP_VSCROLL_POLICY,
140 PROP_HEADERS_VISIBLE,
141 PROP_HEADERS_CLICKABLE,
142 PROP_REORDERABLE,
143 PROP_RULES_HINT,
144 PROP_ENABLE_SEARCH,
145 PROP_SEARCH_COLUMN,
146 PROP_HOVER_SELECTION,
147 PROP_RUBBER_BANDING,
148 PROP_ENABLE_GRID_LINES,
149 PROP_TOOLTIP_COLUMN,
150 PROP_SPECIAL_CELLS,
151 PROP_FIXED_HEIGHT,
152 PROP_FIXED_HEIGHT_SET
153 };
155 /* object signals */
158 guint prop_id,
162 guint prop_id,
168 /* gtkwidget signals */
200 GtkDirectionType direction);
205 gboolean was_grabbed);
207 GtkStateType previous_state);
209 /* container signals */
213 gboolean include_internals,
214 GtkCallback callback,
215 gpointer callback_data);
217 /* Source side drag signals */
225 guint info,
226 guint time);
230 /* Target side drag signals */
233 guint time);
236 gint x,
237 gint y,
238 guint time);
241 gint x,
242 gint y,
243 guint time);
246 gint x,
247 gint y,
249 guint info,
250 guint time);
252 /* tree_model signals */
257 GtkMovementStep step,
258 gint count);
262 gboolean start_editing,
263 PsppSheetSelectMode mode);
268 gpointer data);
272 gpointer data);
275 gpointer data);
280 gpointer data);
282 /* Incremental reflow */
294 gint offset);
299 /* Internal functions */
307 guint keyval,
308 guint modmask,
309 gboolean add_shifted_binding,
310 GtkMovementStep step,
311 gint count);
316 gint i,
324 gboolean focus_to_cell);
329 gint count,
330 PsppSheetSelectMode mode);
332 gint count,
333 PsppSheetSelectMode mode);
335 gint count,
336 PsppSheetSelectMode mode);
338 gint count,
339 PsppSheetSelectMode mode);
341 gint count);
343 gint count,
344 PsppSheetSelectMode mode);
347 gboolean clear_and_select,
348 gboolean clamp_node,
349 PsppSheetSelectMode mode);
357 /* interactive search */
363 gpointer user_data);
366 gpointer data);
367 #if GTK3_TRANSITION
370 #endif
375 gpointer data);
390 gboolean up);
392 gint column,
395 gpointer search_data);
401 gint n);
406 gint x,
407 gint y,
408 gint width,
409 gint height);
413 GdkEventButton *,
414 PsppSheetView *);
422 guint flags);
424 gboolean keybinding);
428 gint drop_position);
429 static void
433 gboolean subtract_focus_rect,
436 gint height,
439 /* GtkBuildable */
455 \f
457 /* GType Methods
458 */
462 pspp_sheet_view_buildable_init)
465 static void
469 {
470 GtkRequisition requisition;
475 }
477 static void
481 {
482 GtkRequisition requisition;
487 }
489 static void
491 {
507 /* GObject signals */
513 /* GtkWidget signals */
523 /*widget_class->configure_event = pspp_sheet_view_configure;*/
545 /* GtkContainer signals */
558 /* Properties */
561 PROP_MODEL,
565 GTK_TYPE_TREE_MODEL,
566 GTK_PARAM_READWRITE));
574 PROP_HEADERS_VISIBLE,
578 TRUE,
579 GTK_PARAM_READWRITE));
582 PROP_HEADERS_CLICKABLE,
586 TRUE,
587 GTK_PARAM_READWRITE));
590 PROP_REORDERABLE,
594 FALSE,
595 GTK_PARAM_READWRITE));
598 PROP_RULES_HINT,
602 FALSE,
603 GTK_PARAM_READWRITE));
606 PROP_ENABLE_SEARCH,
610 TRUE,
611 GTK_PARAM_READWRITE));
614 PROP_SEARCH_COLUMN,
619 G_MAXINT,
621 GTK_PARAM_READWRITE));
623 /**
624 * PsppSheetView:hover-selection:
625 *
626 * Enables of disables the hover selection mode of @tree_view.
627 * Hover selection makes the selected row follow the pointer.
628 * Currently, this works only for the selection modes
629 * %PSPP_SHEET_SELECTION_SINGLE and %PSPP_SHEET_SELECTION_BROWSE.
630 *
631 * This mode is primarily intended for treeviews in popups, e.g.
632 * in #GtkComboBox or #GtkEntryCompletion.
633 *
634 * Since: 2.6
635 */
637 PROP_HOVER_SELECTION,
641 FALSE,
642 GTK_PARAM_READWRITE));
645 PROP_RUBBER_BANDING,
649 FALSE,
650 GTK_PARAM_READWRITE));
653 PROP_ENABLE_GRID_LINES,
657 PSPP_TYPE_SHEET_VIEW_GRID_LINES,
658 PSPP_SHEET_VIEW_GRID_LINES_NONE,
659 GTK_PARAM_READWRITE));
662 PROP_TOOLTIP_COLUMN,
667 G_MAXINT,
669 GTK_PARAM_READWRITE));
672 PROP_SPECIAL_CELLS,
676 PSPP_TYPE_SHEET_VIEW_SPECIAL_CELLS,
677 PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT,
678 GTK_PARAM_READWRITE));
681 PROP_FIXED_HEIGHT,
684 P_("Height of a single row. Normally the height of a row is determined automatically. Writing this property sets fixed-height-set to true, preventing this property's value from changing."),
686 G_MAXINT,
688 GTK_PARAM_READWRITE));
691 PROP_FIXED_HEIGHT_SET,
695 FALSE,
696 GTK_PARAM_READWRITE));
698 /* Style properties */
699 #define _TREE_VIEW_EXPANDER_SIZE 12
700 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
701 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
708 G_MAXINT,
709 _TREE_VIEW_EXPANDER_SIZE,
710 GTK_PARAM_READABLE));
717 G_MAXINT,
718 _TREE_VIEW_VERTICAL_SEPARATOR,
719 GTK_PARAM_READABLE));
726 G_MAXINT,
727 _TREE_VIEW_HORIZONTAL_SEPARATOR,
728 GTK_PARAM_READABLE));
734 TRUE,
735 GTK_PARAM_READABLE));
741 GDK_TYPE_COLOR,
742 GTK_PARAM_READABLE));
748 GDK_TYPE_COLOR,
749 GTK_PARAM_READABLE));
755 FALSE,
756 GTK_PARAM_READABLE));
763 GTK_PARAM_READABLE));
770 GTK_PARAM_READABLE));
777 GTK_PARAM_READABLE));
779 /* Signals */
780 #if GTK3_TRANSITION
781 /**
782 * PsppSheetView::set-scroll-adjustments
783 * @horizontal: the horizontal #GtkAdjustment
784 * @vertical: the vertical #GtkAdjustment
785 *
786 * Set the scroll adjustments for the tree view. Usually scrolled containers
787 * like #GtkScrolledWindow will emit this signal to connect two instances
788 * of #GtkScrollbar to the scroll directions of the #PsppSheetView.
789 */
796 psppire_marshal_VOID__OBJECT_OBJECT,
798 GTK_TYPE_ADJUSTMENT,
799 GTK_TYPE_ADJUSTMENT);
800 #endif
802 /**
803 * PsppSheetView::row-activated:
804 * @tree_view: the object on which the signal is emitted
805 * @path: the #GtkTreePath for the activated row
806 * @column: the #PsppSheetViewColumn in which the activation occurred
807 *
808 * The "row-activated" signal is emitted when the method
809 * pspp_sheet_view_row_activated() is called or the user double clicks
810 * a treeview row. It is also emitted when a non-editable row is
811 * selected and one of the keys: Space, Shift+Space, Return or
812 * Enter is pressed.
813 *
814 * For selection handling refer to the <link linkend="TreeWidget">tree
815 * widget conceptual overview</link> as well as #PsppSheetSelection.
816 */
823 psppire_marshal_VOID__BOXED_OBJECT,
825 GTK_TYPE_TREE_PATH,
826 PSPP_TYPE_SHEET_VIEW_COLUMN);
828 /**
829 * PsppSheetView::columns-changed:
830 * @tree_view: the object on which the signal is emitted
831 *
832 * The number of columns of the treeview has changed.
833 */
837 G_SIGNAL_RUN_LAST,
840 g_cclosure_marshal_VOID__VOID,
843 /**
844 * PsppSheetView::cursor-changed:
845 * @tree_view: the object on which the signal is emitted
846 *
847 * The position of the cursor (focused cell) has changed.
848 */
852 G_SIGNAL_RUN_LAST,
855 g_cclosure_marshal_VOID__VOID,
864 psppire_marshal_BOOLEAN__ENUM_INT,
866 GTK_TYPE_MOVEMENT_STEP,
867 G_TYPE_INT);
875 psppire_marshal_BOOLEAN__VOID,
884 psppire_marshal_BOOLEAN__VOID,
893 psppire_marshal_BOOLEAN__BOOLEAN,
903 psppire_marshal_BOOLEAN__VOID,
912 psppire_marshal_BOOLEAN__VOID,
915 /* Key bindings */
917 {
1007 gtk_binding_entry_add_signal (binding_set[i], GDK_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1009 gtk_binding_entry_add_signal (binding_set[i], GDK_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1010 }
1012 gtk_binding_entry_add_signal (binding_set[0], GDK_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1013 gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1018 gtk_binding_entry_add_signal (binding_set[0], GDK_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1019 gtk_binding_entry_add_signal (binding_set[0], GDK_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1021 gtk_binding_entry_add_signal (binding_set[0], GDK_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1024 gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1045 gtk_binding_entry_add_signal (binding_set[0], GDK_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1048 }
1050 static void
1052 {
1054 }
1056 static void
1058 {
1059 tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, PSPP_TYPE_SHEET_VIEW, PsppSheetViewPrivate);
1067 /* We need some padding */
1125 }
1127 \f
1129 /* GObject Methods
1130 */
1132 static void
1134 guint prop_id,
1137 {
1143 {
1199 {
1202 {
1205 }
1206 }
1207 else
1208 {
1210 {
1214 }
1215 }
1220 }
1221 }
1223 static void
1225 guint prop_id,
1228 {
1234 {
1292 }
1293 }
1295 static void
1297 {
1306 {
1310 }
1313 {
1316 }
1318 {
1321 }
1324 {
1327 }
1331 }
1333 \f
1335 static void
1340 {
1342 }
1344 static void
1346 {
1352 {
1355 }
1362 {
1365 }
1368 {
1371 }
1374 {
1377 }
1381 {
1384 }
1388 {
1391 }
1399 /* destroy interactive search dialog */
1401 {
1406 {
1409 }
1410 }
1413 {
1416 }
1419 {
1422 }
1428 }
1430 \f
1432 /* GtkWidget Methods
1433 */
1435 /* GtkWidget::map helper */
1436 static void
1438 {
1444 {
1448 {
1454 }
1456 {
1461 {
1464 }
1465 else
1467 }
1469 }
1470 }
1472 static void
1474 {
1482 {
1487 {
1490 }
1491 }
1497 }
1499 static void
1501 {
1504 GdkWindowAttr attributes;
1505 gint attributes_mask;
1506 GtkAllocation allocation;
1507 GtkAllocation old_allocation;
1514 /* Make the main, clipping window */
1531 /* Make the window for the tree */
1537 GDK_SCROLL_MASK |
1538 GDK_POINTER_MOTION_MASK |
1539 GDK_ENTER_NOTIFY_MASK |
1540 GDK_LEAVE_NOTIFY_MASK |
1541 GDK_BUTTON_PRESS_MASK |
1542 GDK_BUTTON_RELEASE_MASK |
1549 /* Make the column header window */
1555 GDK_SCROLL_MASK |
1556 GDK_BUTTON_PRESS_MASK |
1557 GDK_BUTTON_RELEASE_MASK |
1558 GDK_KEY_PRESS_MASK |
1559 GDK_KEY_RELEASE_MASK |
1566 /* Add them all up. */
1569 gdk_window_set_background (tree_view->priv->bin_window, >k_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
1570 gtk_style_set_background (gtk_widget_get_style (widget), tree_view->priv->header_window, GTK_STATE_NORMAL);
1574 {
1579 }
1584 /* Need to call those here, since they create GCs */
1588 }
1590 static void
1592 {
1600 {
1603 }
1606 {
1609 }
1612 {
1615 }
1618 {
1621 }
1624 {
1627 }
1630 {
1633 }
1647 {
1651 }
1654 {
1658 }
1661 {
1664 {
1669 }
1671 }
1672 }
1674 /* GtkWidget::size_request helper */
1675 static void
1677 {
1683 {
1685 {
1686 GtkRequisition requisition;
1692 }
1693 }
1694 }
1697 /* Called only by ::size_request */
1698 static void
1700 {
1703 gint i;
1706 {
1711 }
1716 /* keep this in sync with size_allocate below */
1718 {
1725 {
1727 }
1728 else
1729 {
1731 }
1739 }
1742 }
1744 static void
1747 {
1751 /* we validate some rows initially just to make sure we have some size.
1752 * In practice, with a lot of static lists, this should get a good width.
1753 */
1764 {
1766 GtkRequisition child_requisition;
1772 }
1773 }
1775 static void
1778 {
1782 gboolean rtl;
1788 for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
1789 list;
1791 {
1794 {
1795 GdkRectangle invalid_rect;
1796 GtkAllocation allocation;
1806 }
1809 }
1810 }
1812 static void
1814 {
1816 gboolean rtl;
1820 for (last_column = (rtl ? g_list_first (tree_view->priv->columns) : g_list_last (tree_view->priv->columns));
1821 last_column;
1823 {
1825 {
1828 }
1829 }
1830 }
1832 static gint
1835 {
1836 gint real_requested_width;
1839 {
1841 }
1842 else
1843 {
1845 }
1853 }
1855 static gboolean
1858 {
1862 }
1864 /* GtkWidget::size_allocate helper */
1865 static void
1868 {
1872 GtkAllocation col_allocation;
1873 GtkAllocation allocation;
1879 gboolean rtl;
1886 ;
1894 ;
1901 /* find out how many extra space and expandable columns we have */
1903 {
1909 full_requested_width += pspp_sheet_view_get_real_requested_width_from_column (tree_view, column);
1912 number_of_expand_columns++;
1913 }
1919 else
1925 {
1927 gint old_width;
1935 /* We need to handle the dragged button specially.
1936 */
1938 {
1939 GtkAllocation drag_allocation;
1948 }
1950 real_requested_width = pspp_sheet_view_get_real_requested_width_from_column (tree_view, column);
1956 {
1958 {
1959 /* We add the remander to the last column as
1960 * */
1962 }
1963 else
1964 {
1967 number_of_expand_columns --;
1968 }
1969 }
1987 }
1989 /* We change the width here. The user might have been resizing columns,
1990 * so the total width of the tree view changes.
1991 */
1998 }
2000 static void
2003 {
2007 GtkAllocation old_allocation;
2019 {
2020 GtkAllocation allocation;
2025 /* totally ignore our child's requisition */
2031 }
2033 /* We size-allocate the columns first because the width of the
2034 * tree view (used in updating the adjustments below) might change.
2035 */
2042 gtk_adjustment_set_upper (tree_view->priv->hadjustment, MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment), tree_view->priv->width));
2045 {
2047 {
2049 {
2050 gtk_adjustment_set_value (tree_view->priv->hadjustment, MAX (tree_view->priv->width - allocation->width, 0));
2052 }
2054 {
2055 gtk_adjustment_set_value (tree_view->priv->hadjustment, CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) - allocation->width + old_allocation.width, 0, tree_view->priv->width - allocation->width));
2056 }
2057 else
2058 gtk_adjustment_set_value (tree_view->priv->hadjustment, CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - gtk_adjustment_get_value (tree_view->priv->hadjustment)), 0, tree_view->priv->width - allocation->width));
2059 }
2060 else
2061 {
2064 }
2065 }
2066 else
2067 if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width)
2068 gtk_adjustment_set_value (tree_view->priv->hadjustment, MAX (tree_view->priv->width - allocation->width, 0));
2072 gtk_adjustment_set_page_size (tree_view->priv->vadjustment, allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view));
2073 gtk_adjustment_set_step_increment (tree_view->priv->vadjustment, gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1);
2074 gtk_adjustment_set_page_increment (tree_view->priv->vadjustment, gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9);
2076 gtk_adjustment_set_upper (tree_view->priv->vadjustment, MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment), tree_view->priv->height));
2080 /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2083 else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
2088 else
2092 {
2106 }
2112 {
2115 {
2117 {
2120 }
2121 }
2123 /* This little hack only works if we have an LTR locale, and no column has the */
2125 {
2129 else
2131 }
2132 }
2133 }
2135 /* Grabs the focus and unsets the PSPP_SHEET_VIEW_DRAW_KEYFOCUS flag */
2136 static void
2138 {
2144 }
2146 gboolean
2149 {
2151 }
2153 void
2156 {
2158 }
2160 void
2163 {
2165 }
2167 gint
2169 gint node)
2170 {
2172 }
2174 gint
2176 gint node)
2177 {
2179 }
2181 static gboolean
2183 {
2187 {
2191 }
2194 }
2196 static gboolean
2198 gint node,
2201 {
2203 PsppSheetSelectionMode mode;
2205 gboolean update_anchor;
2206 gboolean handled;
2207 guint modifiers;
2221 {
2226 }
2227 else
2232 {
2238 }
2240 {
2243 {
2249 }
2250 else
2252 }
2255 {
2257 {
2260 }
2264 else
2268 }
2271 {
2277 {
2280 }
2281 else
2282 {
2285 }
2294 }
2295 else
2299 {
2305 path);
2306 }
2310 }
2312 static gboolean
2319 {
2320 gint y_offset;
2321 gboolean rtl;
2323 gint new_y;
2325 /* find the node that was clicked */
2338 /* Let the column have a chance at selecting it. */
2340 for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2342 {
2351 {
2354 }
2356 /* we found the focus column */
2362 }
2365 }
2367 static gboolean
2370 {
2374 gint i;
2375 GdkRectangle background_area;
2376 GdkRectangle cell_area;
2377 gboolean rtl;
2383 /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2384 * we're done handling the button press.
2385 */
2388 {
2391 gint dval;
2397 /* Empty tree? */
2399 {
2402 }
2406 {
2409 }
2416 /* select */
2421 /* we only handle selection modifications on the first button press
2422 */
2424 {
2437 {
2440 }
2442 {
2445 }
2446 else
2447 {
2449 }
2457 column);
2458 }
2460 /* the treeview may have been scrolled because of _set_cursor,
2461 * correct here
2462 */
2470 /* Save press to possibly begin a drag
2471 */
2474 {
2483 {
2494 }
2495 }
2497 /* Test if a double click happened on the same row. */
2499 {
2506 NULL);
2508 /* Same conditions as _gdk_event_button_generate */
2513 {
2514 /* We do no longer compare paths of this row and the
2515 * row clicked previously. We use the double click
2516 * distance to decide whether this is a valid click,
2517 * allowing the mouse to slightly move over another row.
2518 */
2524 }
2525 else
2526 {
2530 }
2531 }
2534 {
2540 }
2544 /* If we activated the row through a double click we don't want to grab
2545 * focus back, as moving focus to another widget is pretty common.
2546 */
2551 }
2553 /* We didn't click in the window. Let's check to see if we clicked on a column resize window.
2554 */
2556 {
2561 {
2562 gpointer drag_data;
2565 GDK_POINTER_MOTION_HINT_MASK |
2566 GDK_BUTTON1_MOTION_MASK |
2567 GDK_BUTTON_RELEASE_MASK,
2575 /* block attached dnd signal handler */
2579 G_SIGNAL_MATCH_DATA,
2581 drag_data);
2590 }
2591 }
2593 }
2595 /* GtkWidget::button_release_event helper */
2596 static gboolean
2599 {
2602 gboolean rtl;
2610 /* Move the button back */
2615 gtk_widget_set_parent_window (tree_view->priv->drag_column->button, tree_view->priv->header_window);
2620 {
2623 }
2624 else
2630 {
2635 }
2636 else
2637 {
2642 }
2655 /* Reset our flags */
2660 }
2662 /* GtkWidget::button_release_event helper */
2663 static gboolean
2666 {
2668 gpointer drag_data;
2674 /* unblock attached dnd signal handler */
2678 G_SIGNAL_MATCH_DATA,
2680 drag_data);
2687 }
2689 static gboolean
2692 {
2697 GtkTreeIter iter;
2699 GdkRectangle background_area;
2700 GdkRectangle cell_area;
2701 GdkRectangle area;
2702 guint modifiers;
2703 guint flags;
2709 /* Ignore a released button, if that button wasn't depressed */
2717 /* decide if we edit */
2738 path_string,
2758 column,
2759 path,
2760 cell_editable,
2763 flags);
2767 }
2769 static gboolean
2772 {
2778 {
2784 }
2799 }
2801 static gboolean
2804 {
2814 }
2816 /* GtkWidget::motion_event function set.
2817 */
2819 static void
2822 /* these are in bin_window coords */
2823 gint x,
2824 gint y)
2825 {
2829 {
2837 }
2838 }
2841 static void
2844 /* these are in bin_window coords */
2845 gint x,
2846 gint y)
2847 {
2854 {
2856 {
2858 {
2864 {
2867 }
2869 }
2870 }
2874 }
2877 }
2879 static void
2881 {
2887 }
2889 static void
2891 gint x,
2892 gint y)
2893 {
2901 {
2904 }
2914 }
2919 /* Our motion arrow is either a box (in the case of the original spot)
2920 * or an arrow. It is expander_size wide.
2921 */
2922 /*
2923 * 11111111111111
2924 * 01111111111110
2925 * 00111111111100
2926 * 00011111111000
2927 * 00001111110000
2928 * 00000111100000
2929 * 00000111100000
2930 * 00000111100000
2931 * ~ ~ ~ ~ ~ ~ ~
2932 * 00000111100000
2933 * 00000111100000
2934 * 00000111100000
2935 * 00001111110000
2936 * 00011111111000
2937 * 00111111111100
2938 * 01111111111110
2939 * 11111111111111
2940 */
2942 static void
2944 {
2945 #if GTK3_TRANSITION
2949 gint x;
2950 gint y;
2951 gint width;
2952 gint height;
2954 GdkWindowAttr attributes;
2955 guint attributes_mask;
2962 {
2963 GdkRectangle visible_rect;
2967 else
2974 else
2976 }
2978 /* We want to draw the rectangle over the initial location. */
2980 {
2982 GdkColor col;
2985 {
2987 {
2989 NULL);
2991 }
3001 attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3003 tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3020 }
3021 }
3023 {
3026 GdkColor col;
3030 /* Get x, y, width, height of arrow */
3033 {
3036 }
3037 else
3038 {
3041 }
3045 /* Create the new window */
3047 {
3049 {
3051 NULL);
3053 }
3059 attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3075 /* Draw the 2 arrows as per above */
3079 {
3084 j++;
3085 else
3086 j--;
3087 }
3092 }
3096 }
3099 {
3102 GdkColor col;
3106 /* Get x, y, width, height of arrow */
3114 else
3120 /* Create the new window */
3123 {
3125 {
3127 NULL);
3129 }
3135 attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3150 /* Draw the 2 arrows as per above */
3155 {
3156 gint k;
3159 else
3164 j--;
3165 }
3170 }
3174 }
3175 else
3176 {
3180 }
3184 #endif
3185 }
3187 static gboolean
3190 {
3191 gint x;
3192 gint new_width;
3200 else
3210 {
3213 #if 0
3216 #endif
3218 }
3221 }
3224 static void
3226 {
3229 gint mouse_x;
3233 {
3238 }
3240 /* if (reorder && reorder == tree_view->priv->cur_reorder)
3241 return;*/
3245 }
3247 static void
3249 {
3250 GdkRectangle visible_rect;
3251 gint y;
3252 gint offset;
3253 gfloat value;
3260 /* see if we are near the edge. */
3263 {
3267 }
3270 gtk_adjustment_get_upper (tree_view->priv->vadjustment) - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
3272 }
3274 static gboolean
3276 {
3277 GdkRectangle visible_rect;
3278 gint x;
3279 gint offset;
3280 gfloat value;
3286 /* See if we are near the edge. */
3289 {
3293 }
3297 0.0, gtk_adjustment_get_upper (tree_view->priv->hadjustment) - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
3302 }
3304 static gboolean
3307 {
3311 GtkAllocation allocation;
3313 /* Sanity Check */
3318 /* Handle moving the header */
3325 /* autoscroll, if needed */
3327 /* Update the current reorder position and arrow; */
3331 }
3333 static void
3335 {
3340 {
3345 /* The anchor path should be set to the start path */
3355 tmp_path);
3359 /* ... and the cursor to the end path */
3362 pspp_sheet_view_real_set_cursor (PSPP_SHEET_VIEW (tree_view), tmp_path, FALSE, FALSE, 0); /* XXX mode? */
3366 }
3368 /* Clear status variables */
3375 }
3377 static void
3381 gboolean select,
3382 gboolean skip_start,
3383 gboolean skip_end)
3384 {
3388 /* We skip the first node and jump inside the loop */
3392 do
3393 {
3394 /* Small optimization by assuming insensitive nodes are never
3395 * selected.
3396 */
3398 {
3402 {
3403 /* Toggle the selection state */
3406 else
3408 }
3409 else
3411 }
3412 else
3413 {
3414 /* Mirror the above */
3418 {
3419 /* Toggle the selection state */
3422 else
3424 }
3425 else
3427 }
3434 skip_first:
3439 /* Ran out of tree */
3444 }
3446 }
3448 static gint
3451 {
3453 }
3455 static gint
3457 gint height,
3459 {
3464 {
3467 }
3468 else
3469 {
3472 }
3473 }
3475 static void
3477 {
3481 pspp_sheet_view_find_offset (tree_view, MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &start_node);
3482 pspp_sheet_view_find_offset (tree_view, MAX (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &end_node);
3484 /* Handle the start area first */
3486 {
3488 start_node,
3489 end_node,
3490 TRUE,
3491 FALSE,
3492 FALSE);
3493 }
3495 {
3496 /* New node is above the old one; selection became bigger */
3498 start_node,
3500 TRUE,
3501 FALSE,
3502 TRUE);
3503 }
3505 {
3506 /* New node is below the old one; selection became smaller */
3509 start_node,
3510 FALSE,
3511 FALSE,
3512 TRUE);
3513 }
3517 /* Next, handle the end area */
3519 {
3520 /* In the event this happens, start_node was also -1; this case is
3521 * handled above.
3522 */
3523 }
3525 {
3526 /* Find the last node in the tree */
3530 /* Selection reached end of the tree */
3533 end_node,
3534 TRUE,
3535 TRUE,
3536 FALSE);
3537 }
3539 {
3540 /* New node is below the old one; selection became bigger */
3543 end_node,
3544 TRUE,
3545 TRUE,
3546 FALSE);
3547 }
3549 {
3550 /* New node is above the old one; selection became smaller */
3552 end_node,
3554 FALSE,
3555 TRUE,
3556 FALSE);
3557 }
3560 }
3562 #define GDK_RECTANGLE_PTR(X) ((GdkRectangle *)(X))
3564 static void
3566 {
3568 cairo_rectangle_int_t old_area;
3569 cairo_rectangle_int_t new_area;
3570 cairo_rectangle_int_t common;
3575 old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
3595 {
3598 /* make sure the border is invalidated */
3608 }
3610 #if GTK_MAJOR_VERSION == 3
3612 #else
3613 {
3614 cairo_rectangle_int_t extents;
3620 }
3621 #endif
3632 column);
3637 }
3639 #if GTK3_TRANSITION
3640 static void
3643 {
3645 GdkRectangle rect;
3646 GdkRectangle rubber_rect;
3651 rubber_rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
3653 rubber_rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
3683 }
3684 #endif
3687 static gboolean
3690 {
3693 gint new_y;
3701 {
3715 }
3717 {
3721 }
3723 /* only check for an initiated drag when a button is pressed */
3740 }
3742 static gboolean
3745 {
3750 /* Resizing a column */
3754 /* Drag column */
3758 /* Sanity check it */
3763 }
3765 /* Invalidate the focus rectangle near the edge of the bin_window; used when
3766 * the tree is empty.
3767 */
3768 static void
3770 {
3771 GdkRectangle area;
3781 }
3783 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
3784 * is empty.
3785 */
3786 static void
3788 {
3804 cr,
3806 widget,
3807 NULL,
3810 }
3812 static void
3815 gint n_visible_columns,
3816 gint min_y,
3817 gint max_y)
3818 {
3827 /* Only draw the lines for visible rows and columns */
3829 {
3831 gint x;
3838 /* Generally the grid lines should fit within the column, but for the
3839 last visible column we put it just past the end of the column.
3840 (Otherwise horizontal grid lines sometimes stick out by one pixel.) */
3843 x--;
3850 }
3851 }
3853 /* Warning: Very scary function.
3854 * Modify at your own risk
3855 *
3856 * KEEP IN SYNC WITH pspp_sheet_view_create_row_drag_icon()!
3857 * FIXME: It's not...
3858 */
3859 static gboolean
3862 {
3869 GtkTreeIter iter;
3870 gint new_y;
3872 gint max_height;
3873 GdkRectangle background_area;
3874 GdkRectangle cell_area;
3875 guint flags;
3876 gint bin_window_width;
3877 gint bin_window_height;
3881 gint vertical_separator;
3882 gint horizontal_separator;
3883 gint focus_line_width;
3884 gboolean allow_rules;
3885 gboolean has_special_cell;
3886 gboolean rtl;
3887 gint n_visible_columns;
3888 gint grid_line_width;
3889 gboolean row_ending_details;
3893 GdkRectangle Zarea;
3894 GtkAllocation allocation;
3909 NULL);
3912 {
3915 }
3917 #if GTK3_TRANSITION
3918 /* clip event->area to the visible area */
3921 #endif
3930 bin_window_width =
3933 bin_window_height =
3938 {
3940 cr,
3942 GTK_SHADOW_NONE,
3943 widget,
3946 bin_window_width,
3948 }
3953 /* find the path for the node */
3957 path);
3976 draw_vgrid_lines =
3979 draw_hgrid_lines =
3988 {
3991 n_visible_columns ++;
3992 }
3994 /* Find the last column */
3998 ;
4000 /* and the first */
4004 ;
4006 /* Actually process the expose event. To do this, we want to
4007 * start at the first node of the event, and walk the tree in
4008 * order, drawing each successive node.
4009 */
4012 do
4013 {
4014 gboolean parity;
4018 gboolean selected;
4038 {
4039 /* we *need* to set cell data on all cells before the call
4040 * to _has_special_cell, else _has_special_cell() does not
4041 * return a correct value.
4042 */
4043 for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4044 list;
4046 {
4051 }
4054 }
4055 else
4058 for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4059 list;
4061 {
4064 gboolean selected_column;
4065 GtkStateType state;
4072 else
4075 #if GTK3_TRANSITION
4078 {
4081 }
4082 #endif
4086 else
4091 else
4096 else
4109 {
4111 {
4113 }
4115 {
4118 }
4119 else
4120 {
4123 }
4124 }
4127 {
4130 }
4132 #if GTK3_TRANSITION
4134 {
4137 }
4138 #endif
4144 /* Select the detail for drawing the cell. relevant
4145 * factors are parity, sortedness, and whether to
4146 * display rules.
4147 */
4149 {
4152 {
4155 else
4157 }
4158 else
4159 {
4162 else
4164 }
4165 }
4166 else
4167 {
4170 {
4173 else
4175 }
4176 else
4177 {
4180 else
4182 }
4183 }
4191 else
4194 /* Draw background */
4196 {
4202 /* (I don't like the snprintfs either, but couldn't find a
4203 * less messy way).
4204 */
4211 else
4215 cr,
4216 state,
4217 GTK_SHADOW_NONE,
4218 widget,
4219 new_detail,
4224 }
4225 else
4226 {
4228 cr,
4229 state,
4230 GTK_SHADOW_NONE,
4231 widget,
4232 detail,
4237 }
4240 {
4245 {
4246 #if GTK3_TRANSITION
4252 #else
4256 #endif
4257 }
4260 {
4261 #if GTK3_TRANSITION
4267 #else
4272 #endif
4273 }
4275 }
4278 cr,
4281 flags);
4288 {
4290 cr,
4293 flags);
4294 }
4297 }
4300 {
4302 cr,
4303 GTK_STATE_NORMAL,
4304 GTK_SHADOW_NONE,
4305 widget,
4307 cell_offset,
4311 }
4314 {
4315 /* Draw indicator for the drop
4316 */
4319 gint width;
4322 {
4343 cr,
4345 widget,
4346 (is_first
4353 else
4355 cr,
4357 widget,
4364 }
4366 #if GTK3_TRANSITION
4368 {
4372 highlight_y,
4374 highlight_y);
4375 }
4376 #endif
4377 }
4379 /* draw the big row-spanning focus rectangle, if needed */
4383 {
4385 gint width;
4386 GtkStateType focus_rect_state;
4388 focus_rect_state =
4392 GTK_STATE_NORMAL));
4397 {
4400 }
4401 else
4402 {
4405 }
4409 cr,
4410 focus_rect_state,
4411 widget,
4412 (is_first
4417 else
4419 cr,
4420 focus_rect_state,
4421 widget,
4425 }
4429 do
4430 {
4433 {
4437 /* Sanity Check! */
4439 }
4440 else
4442 }
4444 }
4447 done:
4451 #if GTK3_TRANSITION
4453 {
4455 gint n_rectangles;
4465 }
4466 #endif
4475 }
4478 static gboolean
4481 {
4485 {
4486 gboolean retval;
4494 /* We can't just chain up to Container::expose as it will try to send the
4495 * event to the headers, so we handle propagating it to our children
4496 * (eg. widgets being edited) ourselves.
4497 */
4500 {
4505 }
4508 }
4510 {
4511 gint n_visible_columns;
4515 {
4527 }
4531 {
4534 n_visible_columns ++;
4535 }
4539 cr,
4540 n_visible_columns,
4546 }
4548 {
4551 cr);
4554 }
4557 }
4559 enum
4560 {
4561 DROP_HOME,
4562 DROP_RIGHT,
4563 DROP_LEFT,
4564 DROP_END
4565 };
4567 /* returns 0x1 when no column has been found -- yes it's hackish */
4571 gint drop_position)
4572 {
4581 {
4583 /* find first column where we can drop */
4589 {
4601 if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4602 {
4605 }
4608 }
4613 if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
4615 else
4620 /* find first column after column where we can drop */
4635 {
4642 {
4647 }
4652 if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4653 {
4656 }
4659 }
4664 if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
4666 else
4671 /* find first column before column where we can drop */
4686 {
4692 {
4693 /*if (!tmp_list->prev)
4694 return (PsppSheetViewColumn *)0x1;
4695 */
4696 /*
4697 cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->prev->data);
4698 tmp_list = tmp_list->prev->prev;
4699 continue;*/
4705 }
4710 if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4715 }
4720 if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
4722 else
4727 /* same as DROP_HOME case, but doing it backwards */
4735 {
4741 {
4744 }
4749 if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4754 }
4759 if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
4761 else
4764 }
4767 }
4769 static gboolean
4772 {
4776 {
4781 }
4784 {
4786 {
4789 }
4791 }
4794 {
4796 gboolean rtl;
4801 focus_column;
4803 {
4808 }
4814 {
4818 {
4821 }
4825 {
4837 else
4849 else
4851 }
4854 {
4869 else
4871 }
4874 }
4882 {
4887 {
4892 else
4894 }
4897 {
4902 else
4904 }
4906 {
4911 else
4913 }
4915 {
4920 else
4922 }
4925 }
4926 }
4928 /* Chain up to the parent class. It handles the keybindings. */
4933 {
4936 }
4938 /* We pass the event to the search_entry. If its text changes, then we start
4939 * the typeahead find capabilities. */
4943 {
4947 gboolean retval;
4949 gboolean text_modified;
4950 gulong popup_menu_id;
4954 /* Make a copy of the current text */
4958 ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
4963 NULL);
4965 /* Move the entry off screen */
4972 /* Send the event to the window. If the preedit_changed signal is emitted
4973 * during this event, we will set priv->imcontext_changed */
4980 popup_menu_id);
4982 /* We check to make sure that the entry tried to handle the text, and that
4983 * the text has changed.
4984 */
4990 {
4992 {
4995 }
4996 else
4997 {
5000 }
5001 }
5002 }
5005 }
5007 static gboolean
5010 {
5017 }
5019 /* FIXME Is this function necessary? Can I get an enter_notify event
5020 * w/o either an expose event or a mouse motion event?
5021 */
5022 static gboolean
5025 {
5028 gint new_y;
5030 /* Sanity check it */
5043 /* find the node internally */
5055 }
5057 static gboolean
5060 {
5071 NULL);
5081 }
5084 static gint
5087 {
5094 /* destroy interactive search dialog */
5099 }
5102 /* Incremental Reflow
5103 */
5105 static void
5108 {
5109 GtkAllocation allocation;
5120 }
5122 static gboolean
5125 {
5138 }
5140 /* Returns the row height. */
5141 static gint
5146 {
5150 gint horizontal_separator;
5151 gint vertical_separator;
5152 gint focus_line_width;
5154 gint focus_pad;
5155 gint grid_line_width;
5156 gboolean wide_separators;
5157 gint separator_height;
5167 NULL);
5169 draw_vgrid_lines =
5172 draw_hgrid_lines =
5179 ;
5184 ;
5187 {
5188 gint tmp_width;
5189 gint tmp_height;
5207 {
5210 else
5212 }
5216 }
5223 }
5226 static void
5228 {
5231 GtkTreeIter iter;
5234 gint total_height;
5237 GtkAllocation allocation;
5254 {
5255 /* we are going to scroll, and will update dy */
5260 {
5267 }
5268 else
5269 {
5270 /* two cases:
5271 * 1) row not visible
5272 * 2) row visible
5273 */
5274 gint dy;
5282 {
5283 /* row visible: keep the row at the same position */
5288 }
5289 else
5290 {
5291 /* row not visible */
5294 {
5295 /* row at the beginning -- fixed */
5299 }
5302 {
5303 /* row at the end -- fixed */
5310 {
5313 }
5314 }
5315 else
5316 {
5317 /* row somewhere in the middle, bring it to the top
5318 * of the view
5319 */
5322 }
5323 }
5324 }
5325 }
5326 else
5327 /* the scroll to isn't valid; ignore it.
5328 */
5329 {
5333 }
5337 /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
5338 * backwards is much slower then forward, as there is no iter_prev function.
5339 * We go forwards first in case we run out of tree. Then we go backwards to
5340 * fill out the top.
5341 */
5343 {
5345 do
5346 {
5349 {
5354 /* Sanity Check! */
5356 }
5357 else
5359 }
5366 }
5369 /* If we ran out of tree, and have extra area_below left, we need to add it
5370 * to area_above */
5376 /* We walk backwards */
5378 {
5381 /* Always find the new path in the tree. We cannot just assume
5382 * a gtk_tree_path_prev() is enough here, as there might be children
5383 * in between this node and the previous sibling node. If this
5384 * appears to be a performance hotspot in profiles, we can look into
5385 * intrigate logic for keeping path, node and iter in sync like
5386 * we do for forward walks. (Which will be hard because of the lacking
5387 * iter_prev).
5388 */
5399 }
5401 /* set the dy here to scroll to the path,
5402 * and sync the top row accordingly
5403 */
5407 /* update width/height and queue a resize */
5409 {
5410 GtkRequisition requisition;
5412 /* We temporarily guess a size, under the assumption that it will be the
5413 * same when we get our next size_allocate. If we don't do this, we'll be
5414 * in an inconsistent state if we call top_row_to_dy. */
5417 gtk_adjustment_set_upper (tree_view->priv->hadjustment, MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), (gfloat)requisition.width));
5418 gtk_adjustment_set_upper (tree_view->priv->vadjustment, MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), (gfloat)requisition.height));
5422 }
5431 {
5433 }
5435 }
5437 static void
5439 {
5447 {
5448 GtkTreeIter iter;
5461 }
5462 }
5464 /* Our strategy for finding nodes to validate is a little convoluted. We find
5465 * the left-most uninvalidated node. We then try walking right, validating
5466 * nodes. Once we find a valid node, we repeat the previous process of finding
5467 * the first invalid node.
5468 */
5470 static gboolean
5472 {
5475 {
5478 }
5481 }
5483 static gboolean
5485 {
5486 GtkRequisition requisition;
5496 gtk_adjustment_set_upper (tree_view->priv->hadjustment, MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), (gfloat)requisition.width));
5497 gtk_adjustment_set_upper (tree_view->priv->vadjustment, MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), (gfloat)requisition.height));
5503 }
5505 static gboolean
5507 {
5511 }
5513 static void
5515 {
5520 {
5522 gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
5523 }
5525 {
5527 gdk_threads_add_idle_full (PSPP_SHEET_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
5528 }
5529 }
5531 static gboolean
5533 {
5538 else
5544 }
5546 static void
5548 {
5553 {
5555 gdk_threads_add_idle_full (PSPP_SHEET_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
5556 }
5557 }
5559 static void
5562 gint offset)
5563 {
5567 {
5570 }
5571 else
5572 {
5573 tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
5575 }
5576 }
5578 /* Always call this iff dy is in the visible range. If the tree is empty, then
5579 * it's set to be NULL, and top_row_dy is 0;
5580 */
5581 static void
5583 {
5584 gint offset;
5589 {
5591 }
5592 else
5593 {
5599 {
5601 }
5602 else
5603 {
5607 }
5608 }
5609 }
5611 static void
5613 {
5618 /* Avoid recursive calls */
5624 else
5629 else
5636 {
5637 /* keep dy and set new toprow */
5641 /* DO NOT install the idle handler */
5644 }
5647 {
5648 /* new top row -- do NOT install the idle handler */
5651 }
5656 if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
5657 new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
5664 }
5667 void
5669 {
5671 }
5673 /* Drag-and-drop */
5675 static void
5679 {
5684 }
5688 {
5694 else
5696 }
5699 {
5704 }
5705 DestRow;
5707 static void
5709 {
5714 }
5716 static void
5720 gboolean path_down_mode,
5721 gboolean empty_view_drop,
5722 gboolean drop_append_mode)
5723 {
5727 {
5731 }
5742 }
5747 {
5752 {
5762 else
5769 }
5770 else
5772 }
5774 /* Get/set whether drag_motion requested the drag data and
5775 * drag_data_received should thus not actually insert the data,
5776 * since the data doesn't result from a drop.
5777 */
5778 static void
5780 GdkDragAction suggested_action)
5781 {
5785 }
5787 static GdkDragAction
5789 {
5792 }
5796 {
5798 }
5800 static void
5802 {
5804 }
5808 {
5814 {
5819 di,
5821 }
5824 }
5826 static void
5828 {
5830 }
5832 #if 0
5833 static gint
5835 {
5838 GdkModifierType state;
5841 GdkRectangle visible_rect;
5852 /* See if we are near the edge. */
5857 {
5863 NULL,
5864 NULL);
5867 {
5869 path,
5870 column,
5871 TRUE,
5875 }
5876 }
5881 }
5884 static void
5886 {
5888 {
5891 }
5892 }
5894 static void
5896 {
5898 {
5901 }
5902 }
5904 static gboolean
5906 GType required_iface,
5908 {
5910 {
5912 "on PsppSheetView when using models that don't support "
5913 "the %s interface and enabling drag-and-drop. The simplest way to do this "
5914 "is to connect to '%s' and call "
5915 "g_signal_stop_emission_by_name() in your signal handler to prevent "
5916 "the default handler from running. Look at the source code "
5917 "for the default handler in gtktreeview.c to get an idea what "
5918 "your handler should do. (gtktreeview.c is in the GTK source "
5919 "code.) If you're using GTK from a language other than C, "
5923 }
5924 else
5926 }
5928 static gboolean
5930 {
5940 }
5942 /* Returns TRUE if event should not be propagated to parent widgets */
5943 static gboolean
5946 /* coordinates relative to the widget */
5947 gint x,
5948 gint y,
5951 {
5953 PsppSheetViewDropPosition pos;
5954 PsppSheetViewDropPosition old_pos;
5968 {
5969 /* someone unset us as a drag dest, note that if
5970 * we return FALSE drag_leave isn't called
5971 */
5974 NULL,
5975 PSPP_SHEET_VIEW_DROP_BEFORE);
5980 }
5985 {
5987 }
5993 {
5994 gint n_children;
5997 /* the row got dropped on empty space, let's setup a special case
5998 */
6007 {
6010 }
6011 else
6012 {
6015 }
6020 }
6024 /* If we left the current row's "open" zone, unset the timeout for
6025 * opening the row
6026 */
6035 {
6037 }
6039 out:
6041 {
6048 {
6049 /* Default to MOVE, unless the user has
6050 * pressed ctrl or shift to affect available actions
6051 */
6054 }
6058 }
6059 else
6060 {
6061 /* can't drop here */
6063 NULL,
6064 PSPP_SHEET_VIEW_DROP_BEFORE);
6065 }
6071 }
6077 {
6078 /* adjust path to point to the row the drop goes in front of */
6080 PsppSheetViewDropPosition pos;
6098 else
6099 {
6100 GtkTreeIter iter;
6108 else
6109 {
6112 }
6113 }
6116 }
6118 static gboolean
6121 {
6126 gint button;
6157 NULL,
6166 path))
6172 /* Now we can begin the drag */
6179 button,
6184 out:
6189 }
6193 static void
6196 {
6197 #if GTK3_TRANSITION
6206 /* if the user uses a custom DND source impl, we don't set the icon here */
6216 NULL,
6223 path);
6227 row_pix,
6228 NULL,
6229 /* the + 1 is for the black border in the icon */
6235 #endif
6236 }
6239 static void
6242 {
6243 /* do nothing */
6244 }
6246 /* Default signal implementations for the drag signals */
6247 static void
6251 guint info,
6252 guint time)
6253 {
6276 /* We can implement the GTK_TREE_MODEL_ROW target generically for
6277 * any model; for DragSource models there are some other targets
6278 * we also support.
6279 */
6283 source_row,
6284 selection_data))
6287 /* If drag_data_get does nothing, try providing row data. */
6288 if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
6289 {
6291 model,
6292 source_row);
6293 }
6295 done:
6297 }
6300 static void
6303 {
6326 source_row);
6331 }
6333 static void
6336 guint time)
6337 {
6338 /* unset any highlight row */
6340 NULL,
6341 PSPP_SHEET_VIEW_DROP_BEFORE);
6344 }
6347 static gboolean
6350 /* coordinates relative to the widget */
6351 gint x,
6352 gint y,
6353 guint time)
6354 {
6355 gboolean empty;
6357 PsppSheetViewDropPosition pos;
6360 GdkAtom target;
6369 /* we only know this *after* set_desination_row */
6373 {
6374 /* Can't drop here. */
6376 }
6377 else
6378 {
6382 {
6383 /* Nothing. */
6384 }
6385 else
6386 {
6388 }
6391 {
6392 /* Request data so we can use the source row when
6393 * determining whether to accept the drop
6394 */
6397 }
6398 else
6399 {
6402 }
6403 }
6409 }
6412 static gboolean
6415 /* coordinates relative to the widget */
6416 gint x,
6417 gint y,
6418 guint time)
6419 {
6426 gboolean path_down_mode;
6427 gboolean drop_append_mode;
6449 {
6450 /* in case a motion had requested drag data, change things so we
6451 * treat drag data receives as a drop.
6452 */
6456 drop_append_mode);
6457 }
6462 /* Unset this thing */
6464 NULL,
6465 PSPP_SHEET_VIEW_DROP_BEFORE);
6468 {
6471 }
6472 else
6474 }
6476 static void
6479 /* coordinates relative to the widget */
6480 gint x,
6481 gint y,
6483 guint info,
6484 guint time)
6485 {
6492 GdkDragAction suggested_action;
6493 gboolean path_down_mode;
6494 gboolean drop_append_mode;
6511 {
6512 /* We are getting this data due to a request in drag_motion,
6513 * rather than due to a request in drag_drop, so we are just
6514 * supposed to call drag_status, not actually paste in the
6515 * data.
6516 */
6526 {
6528 path,
6529 selection_data))
6530 {
6532 {
6537 path,
6538 selection_data))
6540 }
6541 else
6543 }
6544 }
6551 /* If you can't drop, remove user drop indicator until the next motion */
6554 NULL,
6555 PSPP_SHEET_VIEW_DROP_BEFORE);
6558 }
6566 {
6568 {
6573 }
6574 }
6577 {
6579 dest_row,
6580 selection_data))
6582 }
6585 accepted,
6587 time);
6591 {
6592 /* special special case drag to "0", scroll to first item */
6595 }
6599 /* drop dest_row */
6601 }
6605 /* GtkContainer Methods
6606 */
6609 static void
6612 {
6619 {
6622 {
6629 }
6632 }
6637 {
6641 {
6644 }
6646 }
6647 }
6649 static void
6651 gboolean include_internals,
6652 GtkCallback callback,
6653 gpointer callback_data)
6654 {
6662 {
6667 }
6672 {
6677 }
6678 }
6680 /* Returns TRUE if the treeview contains no "special" (editable or activatable)
6681 * cells. If so we draw one big row-spanning focus rectangle.
6682 */
6683 static gboolean
6685 {
6692 {
6697 }
6700 }
6702 static void
6705 gboolean clamp_column_visible)
6706 {
6716 }
6718 /* Returns TRUE if the focus is within the headers, after the focus operation is
6719 * done
6720 */
6721 static gboolean
6723 GtkDirectionType dir,
6724 gboolean clamp_column_visible)
6725 {
6730 gboolean rtl;
6739 {
6745 }
6747 /* No headers are visible, or are focusable. We can't focus in or out.
6748 */
6754 {
6760 }
6766 {
6772 {
6776 else
6779 clamp_column_visible);
6781 }
6787 {
6792 else
6795 clamp_column_visible);
6797 }
6800 {
6801 /* The focus moves inside the button. */
6802 /* This is probably a great example of bad UI */
6806 FALSE);
6808 }
6810 /* We need to move the focus among the row of buttons. */
6817 {
6820 }
6823 {
6828 else
6832 {
6835 }
6839 {
6841 {
6843 clamp_column_visible);
6845 }
6846 }
6847 }
6853 }
6856 }
6858 /* This function returns in 'path' the first focusable path, if the given path
6859 * is already focusable, it's the returned one.
6860 *
6861 */
6862 static gboolean
6865 gboolean search_forward,
6867 {
6868 /* XXX this function is trivial given that the sheetview doesn't support
6869 separator rows */
6884 }
6886 static gint
6888 GtkDirectionType direction)
6889 {
6900 /* Case 1. Headers currently have focus. */
6902 {
6904 {
6919 }
6920 }
6922 /* Case 2. We don't have focus at all. */
6924 {
6928 }
6930 /* Case 3. We have focus already. */
6936 /* Other directions caught by the keybindings */
6939 }
6941 static void
6943 {
6947 }
6949 static void
6952 {
6958 {
6959 gdk_window_set_background (tree_view->priv->bin_window, >k_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
6960 gtk_style_set_background (gtk_widget_get_style (widget), tree_view->priv->header_window, GTK_STATE_NORMAL);
6962 }
6966 NULL);
6970 {
6973 }
6977 /* Invalidate cached button style. */
6979 {
6982 }
6985 }
6988 static void
6991 {
6996 {
6998 {
7001 }
7002 }
7005 }
7007 static void
7011 {
7018 else
7022 else
7026 {
7028 pspp_sheet_view_adjustment_changed,
7029 tree_view);
7031 }
7034 {
7036 pspp_sheet_view_adjustment_changed,
7037 tree_view);
7039 }
7042 {
7048 tree_view);
7050 }
7053 {
7059 tree_view);
7061 }
7065 }
7068 static gboolean
7070 GtkMovementStep step,
7071 gint count)
7072 {
7073 PsppSheetSelectMode mode;
7074 GdkModifierType state;
7095 {
7100 }
7101 /* else we assume not pressed */
7104 {
7125 }
7128 }
7130 static void
7133 /* in bin_window coordinates */
7134 gint x,
7135 gint y,
7136 gint width,
7137 gint height)
7138 {
7158 }
7160 void
7163 /* in tree coordinates */
7164 gint x,
7165 gint y,
7166 gint width,
7167 gint height)
7168 {
7171 GdkRectangle allocation;
7177 {
7179 {
7182 }
7183 }
7194 }
7197 /* TreeModel Callbacks
7198 */
7200 static void
7204 gpointer data)
7205 {
7215 else
7226 {
7229 }
7234 path,
7238 {
7241 }
7245 }
7247 static void
7251 gpointer data)
7252 {
7263 {
7266 }
7272 /* Update all row-references */
7280 {
7283 else
7285 }
7286 else
7290 }
7292 static void
7295 gpointer data)
7296 {
7311 /* Ensure we don't have a dangling pointer to a dead node */
7314 /* Cancel editting if we've started */
7318 {
7320 tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
7321 }
7326 {
7329 }
7335 #if 0
7338 #endif
7339 }
7341 static void
7346 gpointer data)
7347 {
7349 gint len;
7351 /* XXX need to adjust selection */
7358 parent,
7359 iter,
7360 new_order);
7368 /* we need to be unprelighted */
7374 }
7377 /* Internal tree functions
7378 */
7381 static void
7386 {
7388 gint total_width;
7390 gboolean rtl;
7401 for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
7402 list;
7404 {
7412 }
7415 {
7418 }
7424 {
7427 else
7429 }
7430 }
7432 /* Make sure the node is visible vertically */
7433 static void
7436 {
7443 /* just return if the node is visible, avoiding a costly expose */
7453 {
7454 /* We process updates because we want to clear old selected items when we scroll.
7455 * if this is removed, we get a "selection streak" at the bottom. */
7459 }
7460 }
7462 static void
7465 gboolean focus_to_cell)
7466 {
7476 {
7477 /* The column is larger than the horizontal page size. If the
7478 * column has cells which can be focussed individually, then we make
7479 * sure the cell which gets focus is fully visible (if even the
7480 * focus cell is bigger than the page size, we make sure the
7481 * left-hand side of the cell is visible).
7482 *
7483 * If the column does not have those so-called special cells, we
7484 * make sure the left-hand side of the column is visible.
7485 */
7488 {
7511 {
7512 if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
7517 }
7518 }
7525 }
7526 else
7527 {
7528 if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
7533 }
7534 }
7536 GtkTreePath *
7539 {
7546 }
7548 void
7552 {
7560 }
7562 static void
7564 guint keyval,
7565 guint modmask,
7566 gboolean add_shifted_binding,
7567 GtkMovementStep step,
7568 gint count)
7569 {
7594 }
7596 static void
7599 {
7603 gboolean rtl;
7605 gint left;
7607 /* We want to precalculate the motion list such that we know what column slots
7608 * are available.
7609 */
7613 /* First, identify all possible drop spots */
7616 else
7620 {
7627 /* If it's not the column moving and func tells us to skip over the column, we continue. */
7630 ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
7631 {
7634 }
7639 tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
7640 }
7642 /* Add the last one */
7645 tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
7646 {
7650 tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
7651 }
7653 /* We quickly check to see if it even makes sense to reorder columns. */
7654 /* If there is nothing that can be moved, then we return */
7659 /* We know there are always 2 slots possbile, as you can always return column. */
7660 /* If that's all there is, return */
7663 ((PsppSheetViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
7664 ((PsppSheetViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
7665 {
7671 }
7672 /* We fill in the ranges for the columns, now that we've isolated them */
7676 {
7681 {
7686 }
7687 else
7688 {
7691 }
7692 }
7693 }
7695 void
7698 {
7700 GtkAllocation allocation;
7715 {
7716 GdkWindowAttr attributes;
7717 guint attributes_mask;
7726 attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
7731 attributes_mask);
7733 }
7742 send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (column->button)));
7768 /* Kids, don't try this at home */
7792 FALSE,
7796 FALSE,
7797 GDK_CURRENT_TIME);
7798 }
7800 void
7804 {
7805 GdkRectangle rect;
7806 GtkAllocation allocation;
7819 {
7820 GdkRectangle new_rect;
7825 }
7826 else
7827 {
7829 }
7830 }
7832 static void
7836 {
7843 }
7845 static void
7848 {
7860 {
7861 /* There's no cursor. Move the cursor to the first selected row, if any
7862 * are selected, otherwise to the first row in the sheetview.
7863 */
7872 {
7873 /* XXX we could avoid doing O(n) work to get this result */
7877 }
7878 else
7879 {
7883 }
7889 {
7893 else
7895 }
7896 }
7899 {
7900 /* Now find a column for the cursor. */
7907 {
7910 {
7912 {
7915 pspp_sheet_selection_select_column (tree_view->priv->selection, tree_view->priv->focus_column);
7917 }
7918 }
7920 }
7921 }
7922 }
7924 static gboolean
7926 gint count,
7927 PsppSheetSelectMode mode)
7928 {
7929 gint selection_count;
7940 /* FIXME: we lost the cursor; should we get the first? */
7947 /* FIXME: we lost the cursor; should we get the first? */
7955 {
7956 /* Don't move the cursor, but just select the current node */
7958 }
7959 else
7960 {
7963 else
7965 }
7970 {
7979 }
7981 /*
7982 * If the list has only one item and multi-selection is set then select
7983 * the row (if not yet selected).
7984 */
7988 {
7991 else
7996 {
7998 }
7999 else
8000 {
8002 }
8003 }
8006 {
8010 }
8011 else
8012 {
8016 {
8020 {
8026 GTK_DIR_TAB_BACKWARD :
8027 GTK_DIR_TAB_FORWARD);
8030 }
8031 }
8032 else
8033 {
8035 }
8036 }
8042 }
8044 static void
8046 gint count,
8047 PsppSheetSelectMode mode)
8048 {
8053 gint y;
8054 gint window_y;
8055 gint vertical_separator;
8062 else
8063 /* This is sorta weird. Focus in should give us a cursor */
8066 gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
8070 {
8071 /* FIXME: we lost the cursor. Should we try to get one? */
8074 }
8080 y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment), (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
8089 {
8092 }
8102 {
8103 /* It looks like we reached the end of the view without finding
8104 * a focusable row. We will step backwards to find the last
8105 * focusable row.
8106 */
8113 }
8118 /* update y */
8133 cleanup:
8136 }
8138 static void
8140 gint count,
8141 PsppSheetSelectMode mode)
8142 {
8146 GtkTreeIter iter;
8149 gboolean rtl;
8158 else
8165 {
8168 }
8173 {
8175 {
8178 }
8179 }
8182 {
8194 {
8197 }
8198 else
8199 {
8202 }
8205 {
8209 }
8210 loop_end:
8213 else
8215 }
8218 {
8222 }
8223 else
8224 {
8226 }
8230 }
8232 static void
8234 gint count,
8235 PsppSheetSelectMode mode)
8236 {
8241 GtkTreeIter iter;
8243 gboolean rtl;
8252 else
8259 {
8262 }
8267 {
8269 {
8272 }
8273 }
8277 {
8289 {
8292 }
8293 else
8294 {
8297 }
8303 loop_end:
8306 else
8308 }
8311 {
8316 }
8320 }
8322 static gboolean
8324 gboolean start_at_focus_column,
8325 gint count)
8326 {
8328 GtkTreeIter iter;
8331 gboolean rtl;
8336 else
8343 {
8346 }
8351 {
8352 list = (rtl
8356 {
8358 {
8361 }
8362 }
8363 }
8364 else
8365 {
8369 }
8372 {
8384 {
8387 }
8388 else
8389 {
8392 }
8396 {
8402 }
8403 loop_end:
8406 else
8408 }
8411 }
8413 static void
8415 gint count)
8416 {
8421 {
8425 }
8429 }
8431 static void
8433 gint count,
8434 PsppSheetSelectMode mode)
8435 {
8448 {
8449 /* Now go forward to find the first focusable row. */
8453 }
8454 else
8455 {
8456 /* Now go backwards to find last focusable row. */
8460 }
8466 {
8469 }
8470 else
8471 {
8473 }
8475 cleanup:
8478 }
8480 static gboolean
8482 {
8493 }
8495 static gboolean
8497 {
8508 }
8510 static gboolean
8512 gboolean start_editing,
8513 PsppSheetSelectMode mode)
8514 {
8532 {
8535 }
8539 {
8541 {
8544 }
8545 }
8548 cursor_node,
8549 cursor_path,
8550 mode,
8551 FALSE);
8553 /* We bail out if the original (tree, node) don't exist anymore after
8554 * handling the selection-changed callback. We do return TRUE because
8555 * the key press has been handled at this point.
8556 */
8574 }
8576 static gboolean
8578 {
8595 {
8598 }
8601 cursor_node,
8602 cursor_path,
8603 PSPP_SHEET_SELECT_MODE_TOGGLE,
8604 FALSE);
8606 /* We bail out if the original (tree, node) don't exist anymore after
8607 * handling the selection-changed callback. We do return TRUE because
8608 * the key press has been handled at this point.
8609 */
8622 }
8624 static gboolean
8626 {
8631 }
8633 /* Cut and paste from gtkwindow.c */
8634 static void
8636 gboolean in)
8637 {
8646 }
8648 static void
8650 {
8661 {
8666 gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
8670 }
8680 GDK_WINDOW_TYPE_HINT_UTILITY);
8684 tree_view);
8687 tree_view);
8690 tree_view);
8693 tree_view);
8705 /* add entry */
8710 tree_view);
8713 tree_view);
8715 #if GTK3_TRANSITION
8719 tree_view);
8720 #endif
8726 }
8728 /* Pops up the interactive search entry. If keybinding is TRUE then the user
8729 * started this by typing the start_interactive_search keybinding. Otherwise, it came from
8730 */
8731 static gboolean
8733 gboolean keybinding)
8734 {
8735 /* We only start interactive search if we have focus or the columns
8736 * have focus. If one of our children have focus, we don't want to
8737 * start the search.
8738 */
8754 {
8762 {
8765 }
8766 }
8782 /* done, show it */
8783 tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
8786 {
8790 tree_view);
8791 }
8796 tree_view);
8798 /* Grab focus will select all the text. We don't want that to happen, so we
8799 * call the parent instance and bypass the selection change. This is probably
8800 * really non-kosher. */
8801 entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
8804 /* send focus-in event */
8807 /* search first matching iter */
8811 }
8813 static gboolean
8815 {
8817 }
8819 /* this function returns the new width of the column being resized given
8820 * the column and x position of the cursor; the x cursor position is passed
8821 * in as a pointer and automagicly corrected if it's beyond min/max limits
8822 */
8823 static gint
8825 gint i,
8827 {
8829 gint width;
8830 gboolean rtl;
8832 /* first translate the x position from gtk_widget_get_window (widget)
8833 * to clist->clist_window
8834 */
8837 width = rtl ? (column->allocation.x + column->allocation.width - *x) : (*x - column->allocation.x);
8839 /* Clamp down the value */
8842 else
8847 *x = rtl ? (column->allocation.x + column->allocation.width - width) : (column->allocation.x + width);
8850 }
8853 /* FIXME this adjust_allocation is a big cut-and-paste from
8854 * GtkCList, needs to be some "official" way to do this
8855 * factored out.
8856 */
8858 {
8864 /* The window to which gtk_widget_get_window (widget) is relative */
8865 #define ALLOCATION_WINDOW(widget) \
8866 (!gtk_widget_get_has_window (widget) ? \
8867 gtk_widget_get_window (widget) : \
8868 gdk_window_get_parent (gtk_widget_get_window (widget)))
8870 static void
8872 gpointer data)
8873 {
8875 GtkAllocation allocation;
8877 /* Need to really size allocate instead of just poking
8878 * into widget->allocation if the widget is not realized.
8879 * FIXME someone figure out why this was.
8880 */
8882 {
8884 {
8890 }
8891 }
8892 else
8893 {
8895 {
8901 adjust_allocation_recurse,
8902 data);
8903 }
8904 }
8905 }
8907 static void
8911 {
8912 ScrollData scroll_data;
8916 else
8923 }
8925 void
8928 /* Callbacks */
8929 static void
8932 {
8934 {
8936 gint dy;
8946 {
8953 {
8962 {
8965 {
8968 }
8969 }
8970 }
8971 }
8975 {
8976 /* update our dy and top_row */
8981 }
8982 }
8983 }
8985 \f
8987 /* Public methods
8988 */
8990 /**
8991 * pspp_sheet_view_new:
8992 *
8993 * Creates a new #PsppSheetView widget.
8994 *
8995 * Return value: A newly created #PsppSheetView widget.
8996 **/
8997 GtkWidget *
8999 {
9001 }
9003 /**
9004 * pspp_sheet_view_new_with_model:
9005 * @model: the model.
9006 *
9007 * Creates a new #PsppSheetView widget with the model initialized to @model.
9008 *
9009 * Return value: A newly created #PsppSheetView widget.
9010 **/
9011 GtkWidget *
9013 {
9015 }
9017 /* Public Accessors
9018 */
9020 /**
9021 * pspp_sheet_view_get_model:
9022 * @tree_view: a #PsppSheetView
9023 *
9024 * Returns the model the #PsppSheetView is based on. Returns %NULL if the
9025 * model is unset.
9026 *
9027 * Return value: A #GtkTreeModel, or %NULL if none is currently being used.
9028 **/
9029 GtkTreeModel *
9031 {
9035 }
9037 /**
9038 * pspp_sheet_view_set_model:
9039 * @tree_view: A #GtkTreeNode.
9040 * @model: (allow-none): The model.
9041 *
9042 * Sets the model for a #PsppSheetView. If the @tree_view already has a model
9043 * set, it will remove it before setting the new model. If @model is %NULL,
9044 * then it will unset the old model.
9045 **/
9046 void
9049 {
9057 {
9060 }
9063 {
9071 pspp_sheet_view_row_changed,
9072 tree_view);
9074 pspp_sheet_view_row_inserted,
9075 tree_view);
9077 pspp_sheet_view_row_deleted,
9078 tree_view);
9080 pspp_sheet_view_rows_reordered,
9081 tree_view);
9109 }
9114 {
9115 gint i;
9118 {
9120 {
9124 {
9127 }
9128 }
9129 }
9135 tree_view);
9139 tree_view);
9143 tree_view);
9147 tree_view);
9151 /* FIXME: do I need to do this? pspp_sheet_view_create_buttons (tree_view); */
9153 }
9162 }
9164 /**
9165 * pspp_sheet_view_get_selection:
9166 * @tree_view: A #PsppSheetView.
9167 *
9168 * Gets the #PsppSheetSelection associated with @tree_view.
9169 *
9170 * Return value: A #PsppSheetSelection object.
9171 **/
9172 PsppSheetSelection *
9174 {
9178 }
9180 /**
9181 * pspp_sheet_view_get_hadjustment:
9182 * @tree_view: A #PsppSheetView
9183 *
9184 * Gets the #GtkAdjustment currently being used for the horizontal aspect.
9185 *
9186 * Return value: A #GtkAdjustment object, or %NULL if none is currently being
9187 * used.
9188 **/
9189 GtkAdjustment *
9191 {
9195 }
9199 {
9201 }
9203 /**
9204 * pspp_sheet_view_set_hadjustment:
9205 * @tree_view: A #PsppSheetView
9206 * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
9207 *
9208 * Sets the #GtkAdjustment for the current horizontal aspect.
9209 **/
9210 void
9213 {
9217 adjustment,
9221 }
9223 static void
9226 {
9233 {
9235 pspp_sheet_view_adjustment_changed,
9236 tree_view);
9238 }
9247 /* FIXME: Adjustment should probably be populated here with fresh values, but
9248 * internal details are too complicated for me to decipher right now.
9249 */
9253 }
9255 /**
9256 * pspp_sheet_view_get_vadjustment:
9257 * @tree_view: A #PsppSheetView
9258 *
9259 * Gets the #GtkAdjustment currently being used for the vertical aspect.
9260 *
9261 * Return value: (transfer none): A #GtkAdjustment object, or %NULL
9262 * if none is currently being used.
9263 *
9264 * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
9265 **/
9266 GtkAdjustment *
9268 {
9272 }
9276 {
9278 }
9280 /**
9281 * pspp_sheet_view_set_vadjustment:
9282 * @tree_view: A #PsppSheetView
9283 * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
9284 *
9285 * Sets the #GtkAdjustment for the current vertical aspect.
9286 *
9287 * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
9288 **/
9289 void
9292 {
9297 }
9299 static void
9302 {
9309 {
9311 pspp_sheet_view_adjustment_changed,
9312 tree_view);
9314 }
9323 /* FIXME: Adjustment should probably be populated here with fresh values, but
9324 * internal details are too complicated for me to decipher right now.
9325 */
9328 }
9330 /* Column and header operations */
9332 /**
9333 * pspp_sheet_view_get_headers_visible:
9334 * @tree_view: A #PsppSheetView.
9335 *
9336 * Returns %TRUE if the headers on the @tree_view are visible.
9337 *
9338 * Return value: Whether the headers are visible or not.
9339 **/
9340 gboolean
9342 {
9346 }
9348 /**
9349 * pspp_sheet_view_set_headers_visible:
9350 * @tree_view: A #PsppSheetView.
9351 * @headers_visible: %TRUE if the headers are visible
9352 *
9353 * Sets the visibility state of the headers.
9354 **/
9355 void
9357 gboolean headers_visible)
9358 {
9362 GtkAllocation allocation;
9375 else
9379 {
9382 {
9383 gdk_window_move_resize (tree_view->priv->bin_window, x, y + TREE_VIEW_HEADER_HEIGHT (tree_view),
9388 }
9389 else
9390 {
9391 gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
9394 {
9398 }
9400 }
9401 }
9403 gtk_adjustment_set_page_size (tree_view->priv->vadjustment, allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view));
9404 gtk_adjustment_set_page_increment (tree_view->priv->vadjustment, (allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2);
9412 }
9414 /**
9415 * pspp_sheet_view_columns_autosize:
9416 * @tree_view: A #PsppSheetView.
9417 *
9418 * Resizes all columns to their optimal width. Only works after the
9419 * treeview has been realized.
9420 **/
9421 void
9423 {
9431 {
9435 }
9439 }
9441 /**
9442 * pspp_sheet_view_set_headers_clickable:
9443 * @tree_view: A #PsppSheetView.
9444 * @setting: %TRUE if the columns are clickable.
9445 *
9446 * Allow the column title buttons to be clicked.
9447 **/
9448 void
9450 gboolean setting)
9451 {
9460 }
9463 /**
9464 * pspp_sheet_view_get_headers_clickable:
9465 * @tree_view: A #PsppSheetView.
9466 *
9467 * Returns whether all header columns are clickable.
9468 *
9469 * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
9470 *
9471 * Since: 2.10
9472 **/
9473 gboolean
9475 {
9485 }
9487 /**
9488 * pspp_sheet_view_set_rules_hint
9489 * @tree_view: a #PsppSheetView
9490 * @setting: %TRUE if the tree requires reading across rows
9491 *
9492 * This function tells GTK+ that the user interface for your
9493 * application requires users to read across tree rows and associate
9494 * cells with one another. By default, GTK+ will then render the tree
9495 * with alternating row colors. Do <emphasis>not</emphasis> use it
9496 * just because you prefer the appearance of the ruled tree; that's a
9497 * question for the theme. Some themes will draw tree rows in
9498 * alternating colors even when rules are turned off, and users who
9499 * prefer that appearance all the time can choose those themes. You
9500 * should call this function only as a <emphasis>semantic</emphasis>
9501 * hint to the theme engine that your tree makes alternating colors
9502 * useful from a functional standpoint (since it has lots of columns,
9503 * generally).
9504 *
9505 **/
9506 void
9508 gboolean setting)
9509 {
9515 {
9518 }
9521 }
9523 /**
9524 * pspp_sheet_view_get_rules_hint
9525 * @tree_view: a #PsppSheetView
9526 *
9527 * Gets the setting set by pspp_sheet_view_set_rules_hint().
9528 *
9529 * Return value: %TRUE if rules are useful for the user of this tree
9530 **/
9531 gboolean
9533 {
9537 }
9539 /* Public Column functions
9540 */
9542 /**
9543 * pspp_sheet_view_append_column:
9544 * @tree_view: A #PsppSheetView.
9545 * @column: The #PsppSheetViewColumn to add.
9546 *
9547 * Appends @column to the list of columns.
9548 *
9549 * Return value: The number of columns in @tree_view after appending.
9550 **/
9551 gint
9554 {
9560 }
9563 /**
9564 * pspp_sheet_view_remove_column:
9565 * @tree_view: A #PsppSheetView.
9566 * @column: The #PsppSheetViewColumn to remove.
9567 *
9568 * Removes @column from @tree_view.
9569 *
9570 * Return value: The number of columns in @tree_view after removing.
9571 **/
9572 gint
9575 {
9584 {
9587 /* no need to, but just to be sure ... */
9589 }
9597 {
9602 {
9608 }
9616 }
9622 }
9624 /**
9625 * pspp_sheet_view_insert_column:
9626 * @tree_view: A #PsppSheetView.
9627 * @column: The #PsppSheetViewColumn to be inserted.
9628 * @position: The position to insert @column in.
9629 *
9630 * This inserts the @column into the @tree_view at @position. If @position is
9631 * -1, then the column is inserted at the end.
9632 *
9633 * Return value: The number of columns in @tree_view after insertion.
9634 **/
9635 gint
9638 gint position)
9639 {
9649 {
9651 }
9660 {
9666 {
9670 }
9672 }
9677 }
9679 /**
9680 * pspp_sheet_view_insert_column_with_attributes:
9681 * @tree_view: A #PsppSheetView
9682 * @position: The position to insert the new column in.
9683 * @title: The title to set the header to.
9684 * @cell: The #GtkCellRenderer.
9685 * @Varargs: A %NULL-terminated list of attributes.
9686 *
9687 * Creates a new #PsppSheetViewColumn and inserts it into the @tree_view at
9688 * @position. If @position is -1, then the newly created column is inserted at
9689 * the end. The column is initialized with the attributes given.
9690 *
9691 * Return value: The number of columns in @tree_view after insertion.
9692 **/
9693 gint
9695 gint position,
9698 ...)
9699 {
9703 gint column_id;
9716 {
9720 }
9727 }
9729 /**
9730 * pspp_sheet_view_insert_column_with_data_func:
9731 * @tree_view: a #PsppSheetView
9732 * @position: Position to insert, -1 for append
9733 * @title: column title
9734 * @cell: cell renderer for column
9735 * @func: function to set attributes of cell renderer
9736 * @data: data for @func
9737 * @dnotify: destroy notifier for @data
9738 *
9739 * Convenience function that inserts a new column into the #PsppSheetView
9740 * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
9741 * attributes (normally using data from the model). See also
9742 * pspp_sheet_view_column_set_cell_data_func(), pspp_sheet_view_column_pack_start().
9743 *
9744 * Return value: number of columns in the tree view post-insert
9745 **/
9746 gint
9748 gint position,
9751 PsppSheetCellDataFunc func,
9752 gpointer data,
9753 GDestroyNotify dnotify)
9754 {
9767 }
9769 /**
9770 * pspp_sheet_view_get_column:
9771 * @tree_view: A #PsppSheetView.
9772 * @n: The position of the column, counting from 0.
9773 *
9774 * Gets the #PsppSheetViewColumn at the given position in the #tree_view.
9775 *
9776 * Return value: The #PsppSheetViewColumn, or %NULL if the position is outside the
9777 * range of columns.
9778 **/
9779 PsppSheetViewColumn *
9781 gint n)
9782 {
9792 }
9794 /**
9795 * pspp_sheet_view_get_columns:
9796 * @tree_view: A #PsppSheetView
9797 *
9798 * Returns a #GList of all the #PsppSheetViewColumn s currently in @tree_view.
9799 * The returned list must be freed with g_list_free ().
9800 *
9801 * Return value: (element-type PsppSheetViewColumn) (transfer container): A list of #PsppSheetViewColumn s
9802 **/
9803 GList *
9805 {
9809 }
9811 /**
9812 * pspp_sheet_view_move_column_after:
9813 * @tree_view: A #PsppSheetView
9814 * @column: The #PsppSheetViewColumn to be moved.
9815 * @base_column: (allow-none): The #PsppSheetViewColumn to be moved relative to, or %NULL.
9816 *
9817 * Moves @column to be after to @base_column. If @base_column is %NULL, then
9818 * @column is placed in the first position.
9819 **/
9820 void
9824 {
9833 {
9836 }
9843 {
9849 }
9850 else
9851 {
9857 }
9860 {
9863 }
9866 }
9868 /**
9869 * pspp_sheet_view_set_column_drag_function:
9870 * @tree_view: A #PsppSheetView.
9871 * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
9872 * @user_data: (allow-none): User data to be passed to @func, or %NULL
9873 * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
9874 *
9875 * Sets a user function for determining where a column may be dropped when
9876 * dragged. This function is called on every column pair in turn at the
9877 * beginning of a column drag to determine where a drop can take place. The
9878 * arguments passed to @func are: the @tree_view, the #PsppSheetViewColumn being
9879 * dragged, the two #PsppSheetViewColumn s determining the drop spot, and
9880 * @user_data. If either of the #PsppSheetViewColumn arguments for the drop spot
9881 * are %NULL, then they indicate an edge. If @func is set to be %NULL, then
9882 * @tree_view reverts to the default behavior of allowing all columns to be
9883 * dropped everywhere.
9884 **/
9885 void
9887 PsppSheetViewColumnDropFunc func,
9888 gpointer user_data,
9889 GDestroyNotify destroy)
9890 {
9899 }
9901 /**
9902 * pspp_sheet_view_scroll_to_point:
9903 * @tree_view: a #PsppSheetView
9904 * @tree_x: X coordinate of new top-left pixel of visible area, or -1
9905 * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
9906 *
9907 * Scrolls the tree view such that the top-left corner of the visible
9908 * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
9909 * in tree coordinates. The @tree_view must be realized before
9910 * this function is called. If it isn't, you probably want to be
9911 * using pspp_sheet_view_scroll_to_cell().
9912 *
9913 * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
9914 **/
9915 void
9917 gint tree_x,
9918 gint tree_y)
9919 {
9930 gtk_adjustment_set_value (hadj, CLAMP (tree_x, gtk_adjustment_get_lower (hadj), gtk_adjustment_get_upper (hadj) - gtk_adjustment_get_page_size (hadj)));
9932 gtk_adjustment_set_value (vadj, CLAMP (tree_y, gtk_adjustment_get_lower (vadj), gtk_adjustment_get_upper (vadj) - gtk_adjustment_get_page_size (vadj)));
9933 }
9935 /**
9936 * pspp_sheet_view_scroll_to_cell:
9937 * @tree_view: A #PsppSheetView.
9938 * @path: (allow-none): The path of the row to move to, or %NULL.
9939 * @column: (allow-none): The #PsppSheetViewColumn to move horizontally to, or %NULL.
9940 * @use_align: whether to use alignment arguments, or %FALSE.
9941 * @row_align: The vertical alignment of the row specified by @path.
9942 * @col_align: The horizontal alignment of the column specified by @column.
9943 *
9944 * Moves the alignments of @tree_view to the position specified by @column and
9945 * @path. If @column is %NULL, then no horizontal scrolling occurs. Likewise,
9946 * if @path is %NULL no vertical scrolling occurs. At a minimum, one of @column
9947 * or @path need to be non-%NULL. @row_align determines where the row is
9948 * placed, and @col_align determines where @column is placed. Both are expected
9949 * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
9950 * right/bottom alignment, 0.5 means center.
9951 *
9952 * If @use_align is %FALSE, then the alignment arguments are ignored, and the
9953 * tree does the minimum amount of work to scroll the cell onto the screen.
9954 * This means that the cell will be scrolled to the edge closest to its current
9955 * position. If the cell is currently visible on the screen, nothing is done.
9956 *
9957 * This function only works if the model is set, and @path is a valid row on the
9958 * model. If the model changes before the @tree_view is realized, the centered
9959 * path will be modified to reflect this change.
9960 **/
9961 void
9965 gboolean use_align,
9966 gfloat row_align,
9967 gfloat col_align)
9968 {
9975 #if 0
9976 g_print ("pspp_sheet_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
9978 #endif
9983 /* Note: Despite the benefits that come from having one code path for the
9984 * scrolling code, we short-circuit validate_visible_area's immplementation as
9985 * it is much slower than just going to the point.
9986 */
9990 {
9998 tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
10006 }
10007 else
10008 {
10009 GdkRectangle cell_rect;
10010 GdkRectangle vis_rect;
10022 {
10024 {
10026 }
10027 else
10028 {
10033 }
10034 }
10037 {
10039 {
10042 }
10043 else
10044 {
10049 }
10050 }
10053 }
10054 }
10056 /**
10057 * pspp_sheet_view_row_activated:
10058 * @tree_view: A #PsppSheetView
10059 * @path: The #GtkTreePath to be activated.
10060 * @column: The #PsppSheetViewColumn to be activated.
10061 *
10062 * Activates the cell determined by @path and @column.
10063 **/
10064 void
10068 {
10072 }
10075 /**
10076 * pspp_sheet_view_get_reorderable:
10077 * @tree_view: a #PsppSheetView
10078 *
10079 * Retrieves whether the user can reorder the tree via drag-and-drop. See
10080 * pspp_sheet_view_set_reorderable().
10081 *
10082 * Return value: %TRUE if the tree can be reordered.
10083 **/
10084 gboolean
10086 {
10090 }
10092 /**
10093 * pspp_sheet_view_set_reorderable:
10094 * @tree_view: A #PsppSheetView.
10095 * @reorderable: %TRUE, if the tree can be reordered.
10096 *
10097 * This function is a convenience function to allow you to reorder
10098 * models that support the #GtkDragSourceIface and the
10099 * #GtkDragDestIface. Both #GtkTreeStore and #GtkListStore support
10100 * these. If @reorderable is %TRUE, then the user can reorder the
10101 * model by dragging and dropping rows. The developer can listen to
10102 * these changes by connecting to the model's row_inserted and
10103 * row_deleted signals. The reordering is implemented by setting up
10104 * the tree view as a drag source and destination. Therefore, drag and
10105 * drop can not be used in a reorderable view for any other purpose.
10106 *
10107 * This function does not give you any degree of control over the order -- any
10108 * reordering is allowed. If more control is needed, you should probably
10109 * handle drag and drop manually.
10110 **/
10111 void
10113 gboolean reorderable)
10114 {
10123 {
10126 };
10129 GDK_BUTTON1_MASK,
10130 row_targets,
10132 GDK_ACTION_MOVE);
10134 row_targets,
10136 GDK_ACTION_MOVE);
10137 }
10138 else
10139 {
10142 }
10147 }
10149 /* If CLEAR_AND_SELECT is true, then the row will be selected and, unless Shift
10150 is pressed, other rows will be unselected.
10152 If CLAMP_NODE is true, then the sheetview will scroll to make the row
10153 visible. */
10154 static void
10157 gboolean clear_and_select,
10158 gboolean clamp_node,
10159 PsppSheetSelectMode mode)
10160 {
10164 {
10169 }
10178 path);
10181 {
10187 FALSE);
10189 /* We have to re-find tree and node here again, somebody might have
10190 * cleared the node or the whole tree in the PsppSheetSelection::changed
10191 * callback. If the nodes differ we bail out here.
10192 */
10199 {
10202 }
10203 }
10206 }
10208 /**
10209 * pspp_sheet_view_get_cursor:
10210 * @tree_view: A #PsppSheetView
10211 * @path: (allow-none): A pointer to be filled with the current cursor path, or %NULL
10212 * @focus_column: (allow-none): A pointer to be filled with the current focus column, or %NULL
10213 *
10214 * Fills in @path and @focus_column with the current path and focus column. If
10215 * the cursor isn't currently set, then *@path will be %NULL. If no column
10216 * currently has focus, then *@focus_column will be %NULL.
10217 *
10218 * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
10219 * you are done with it.
10220 **/
10221 void
10225 {
10229 {
10232 else
10234 }
10237 {
10239 }
10240 }
10242 /**
10243 * pspp_sheet_view_set_cursor:
10244 * @tree_view: A #PsppSheetView
10245 * @path: A #GtkTreePath
10246 * @focus_column: (allow-none): A #PsppSheetViewColumn, or %NULL
10247 * @start_editing: %TRUE if the specified cell should start being edited.
10248 *
10249 * Sets the current keyboard focus to be at @path, and selects it. This is
10250 * useful when you want to focus the user's attention on a particular row. If
10251 * @focus_column is not %NULL, then focus is given to the column specified by
10252 * it. Additionally, if @focus_column is specified, and @start_editing is
10253 * %TRUE, then editing should be started in the specified cell.
10254 * This function is often followed by @gtk_widget_grab_focus (@tree_view)
10255 * in order to give keyboard focus to the widget. Please note that editing
10256 * can only happen when the widget is realized.
10257 *
10258 * If @path is invalid for @model, the current cursor (if any) will be unset
10259 * and the function will return without failing.
10260 **/
10261 void
10265 gboolean start_editing)
10266 {
10269 }
10271 /**
10272 * pspp_sheet_view_set_cursor_on_cell:
10273 * @tree_view: A #PsppSheetView
10274 * @path: A #GtkTreePath
10275 * @focus_column: (allow-none): A #PsppSheetViewColumn, or %NULL
10276 * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
10277 * @start_editing: %TRUE if the specified cell should start being edited.
10278 *
10279 * Sets the current keyboard focus to be at @path, and selects it. This is
10280 * useful when you want to focus the user's attention on a particular row. If
10281 * @focus_column is not %NULL, then focus is given to the column specified by
10282 * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
10283 * contains 2 or more editable or activatable cells, then focus is given to
10284 * the cell specified by @focus_cell. Additionally, if @focus_column is
10285 * specified, and @start_editing is %TRUE, then editing should be started in
10286 * the specified cell. This function is often followed by
10287 * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
10288 * widget. Please note that editing can only happen when the widget is
10289 * realized.
10290 *
10291 * If @path is invalid for @model, the current cursor (if any) will be unset
10292 * and the function will return without failing.
10293 *
10294 * Since: 2.2
10295 **/
10296 void
10301 gboolean start_editing)
10302 {
10311 {
10314 }
10316 /* cancel the current editing, if it exists */
10324 {
10330 {
10333 }
10344 }
10345 }
10347 /**
10348 * pspp_sheet_view_get_bin_window:
10349 * @tree_view: A #PsppSheetView
10350 *
10351 * Returns the window that @tree_view renders to. This is used primarily to
10352 * compare to <literal>event->window</literal> to confirm that the event on
10353 * @tree_view is on the right window.
10354 *
10355 * Return value: A #GdkWindow, or %NULL when @tree_view hasn't been realized yet
10356 **/
10357 GdkWindow *
10359 {
10363 }
10365 /**
10366 * pspp_sheet_view_get_path_at_pos:
10367 * @tree_view: A #PsppSheetView.
10368 * @x: The x position to be identified (relative to bin_window).
10369 * @y: The y position to be identified (relative to bin_window).
10370 * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
10371 * @column: (out) (allow-none): A pointer to a #PsppSheetViewColumn pointer to be filled in, or %NULL
10372 * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
10373 * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
10374 *
10375 * Finds the path at the point (@x, @y), relative to bin_window coordinates
10376 * (please see pspp_sheet_view_get_bin_window()).
10377 * That is, @x and @y are relative to an events coordinates. @x and @y must
10378 * come from an event on the @tree_view only where <literal>event->window ==
10379 * pspp_sheet_view_get_bin_window (<!-- -->)</literal>. It is primarily for
10380 * things like popup menus. If @path is non-%NULL, then it will be filled
10381 * with the #GtkTreePath at that point. This path should be freed with
10382 * gtk_tree_path_free(). If @column is non-%NULL, then it will be filled
10383 * with the column at that point. @cell_x and @cell_y return the coordinates
10384 * relative to the cell background (i.e. the @background_area passed to
10385 * gtk_cell_renderer_render()). This function is only meaningful if
10386 * @tree_view is realized. Therefore this function will always return %FALSE
10387 * if @tree_view is not realized or does not have a model.
10388 *
10389 * For converting widget coordinates (eg. the ones you get from
10390 * GtkWidget::query-tooltip), please see
10391 * pspp_sheet_view_convert_widget_to_bin_window_coords().
10392 *
10393 * Return value: %TRUE if a row exists at that coordinate.
10394 **/
10395 gboolean
10397 gint x,
10398 gint y,
10403 {
10405 gint y_offset;
10427 {
10433 gboolean rtl;
10436 for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
10437 list;
10439 {
10447 {
10457 }
10459 }
10461 /* If found is FALSE and there is a last_column, then it the remainder
10462 * space is in that area
10463 */
10465 {
10467 {
10473 }
10474 else
10475 {
10477 }
10478 }
10479 }
10495 }
10497 /* Computes 'cell_area' from 'background_area', which must be the background
10498 area for a cell. Set 'subtract_focus_rect' to TRUE to compute the cell area
10499 as passed to a GtkCellRenderer's "render" function, or to FALSE to compute
10500 the cell area as passed to _pspp_sheet_view_column_cell_render().
10502 'column' is required to properly adjust 'cell_area->x' and
10503 'cell_area->width'. It may be set to NULL if these values are not of
10504 interest. In this case 'cell_area->x' and 'cell_area->width' will be
10505 returned as 0. */
10506 static void
10510 gboolean subtract_focus_rect,
10512 {
10513 gint vertical_separator;
10514 gint horizontal_separator;
10521 NULL);
10528 {
10533 NULL);
10538 }
10541 {
10542 gint grid_line_width;
10545 NULL);
10550 {
10554 /* Find the last visible column. */
10557 list;
10559 {
10562 {
10565 }
10566 }
10568 /* Find the first visible column. */
10571 list;
10573 {
10576 {
10579 }
10580 }
10583 {
10585 }
10587 {
10590 }
10591 else
10592 {
10595 }
10596 }
10600 {
10603 }
10604 }
10607 {
10610 }
10611 }
10613 /**
10614 * pspp_sheet_view_get_cell_area:
10615 * @tree_view: a #PsppSheetView
10616 * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
10617 * @column: (allow-none): a #PsppSheetViewColumn for the column, or %NULL to get only vertical coordinates
10618 * @rect: rectangle to fill with cell rect
10619 *
10620 * Fills the bounding rectangle in bin_window coordinates for the cell at the
10621 * row specified by @path and the column specified by @column. If @path is
10622 * %NULL, or points to a path not currently displayed, the @y and @height fields
10623 * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
10624 * fields will be filled with 0. The sum of all cell rects does not cover the
10625 * entire tree; there are extra pixels in between rows, for example. The
10626 * returned rectangle is equivalent to the @cell_area passed to
10627 * gtk_cell_renderer_render(). This function is only valid if @tree_view is
10628 * realized.
10629 **/
10630 void
10635 {
10636 GdkRectangle background_area;
10648 }
10650 /**
10651 * pspp_sheet_view_get_background_area:
10652 * @tree_view: a #PsppSheetView
10653 * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
10654 * @column: (allow-none): a #PsppSheetViewColumn for the column, or %NULL to get only vertical coordiantes
10655 * @rect: rectangle to fill with cell background rect
10656 *
10657 * Fills the bounding rectangle in bin_window coordinates for the cell at the
10658 * row specified by @path and the column specified by @column. If @path is
10659 * %NULL, or points to a node not found in the tree, the @y and @height fields of
10660 * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
10661 * fields will be filled with 0. The returned rectangle is equivalent to the
10662 * @background_area passed to gtk_cell_renderer_render(). These background
10663 * areas tile to cover the entire bin window. Contrast with the @cell_area,
10664 * returned by pspp_sheet_view_get_cell_area(), which returns only the cell
10665 * itself, excluding surrounding borders.
10666 *
10667 **/
10668 void
10673 {
10686 {
10687 /* Get vertical coords */
10696 }
10699 {
10704 }
10705 }
10707 /**
10708 * pspp_sheet_view_get_visible_rect:
10709 * @tree_view: a #PsppSheetView
10710 * @visible_rect: rectangle to fill
10711 *
10712 * Fills @visible_rect with the currently-visible region of the
10713 * buffer, in tree coordinates. Convert to bin_window coordinates with
10714 * pspp_sheet_view_convert_tree_to_bin_window_coords().
10715 * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
10716 * scrollable area of the tree.
10717 **/
10718 void
10721 {
10729 {
10730 GtkAllocation allocation;
10736 }
10737 }
10739 /**
10740 * pspp_sheet_view_widget_to_tree_coords:
10741 * @tree_view: a #PsppSheetView
10742 * @wx: X coordinate relative to bin_window
10743 * @wy: Y coordinate relative to bin_window
10744 * @tx: return location for tree X coordinate
10745 * @ty: return location for tree Y coordinate
10746 *
10747 * Converts bin_window coordinates to coordinates for the
10748 * tree (the full scrollable area of the tree).
10749 *
10750 * Deprecated: 2.12: Due to historial reasons the name of this function is
10751 * incorrect. For converting coordinates relative to the widget to
10752 * bin_window coordinates, please see
10753 * pspp_sheet_view_convert_widget_to_bin_window_coords().
10754 *
10755 **/
10756 void
10758 gint wx,
10759 gint wy,
10762 {
10769 }
10771 /**
10772 * pspp_sheet_view_tree_to_widget_coords:
10773 * @tree_view: a #PsppSheetView
10774 * @tx: tree X coordinate
10775 * @ty: tree Y coordinate
10776 * @wx: return location for X coordinate relative to bin_window
10777 * @wy: return location for Y coordinate relative to bin_window
10778 *
10779 * Converts tree coordinates (coordinates in full scrollable area of the tree)
10780 * to bin_window coordinates.
10781 *
10782 * Deprecated: 2.12: Due to historial reasons the name of this function is
10783 * incorrect. For converting bin_window coordinates to coordinates relative
10784 * to bin_window, please see
10785 * pspp_sheet_view_convert_bin_window_to_widget_coords().
10786 *
10787 **/
10788 void
10790 gint tx,
10791 gint ty,
10794 {
10801 }
10804 /**
10805 * pspp_sheet_view_convert_widget_to_tree_coords:
10806 * @tree_view: a #PsppSheetView
10807 * @wx: X coordinate relative to the widget
10808 * @wy: Y coordinate relative to the widget
10809 * @tx: return location for tree X coordinate
10810 * @ty: return location for tree Y coordinate
10811 *
10812 * Converts widget coordinates to coordinates for the
10813 * tree (the full scrollable area of the tree).
10814 *
10815 * Since: 2.12
10816 **/
10817 void
10819 gint wx,
10820 gint wy,
10823 {
10834 }
10836 /**
10837 * pspp_sheet_view_convert_tree_to_widget_coords:
10838 * @tree_view: a #PsppSheetView
10839 * @tx: X coordinate relative to the tree
10840 * @ty: Y coordinate relative to the tree
10841 * @wx: return location for widget X coordinate
10842 * @wy: return location for widget Y coordinate
10843 *
10844 * Converts tree coordinates (coordinates in full scrollable area of the tree)
10845 * to widget coordinates.
10846 *
10847 * Since: 2.12
10848 **/
10849 void
10851 gint tx,
10852 gint ty,
10855 {
10866 }
10868 /**
10869 * pspp_sheet_view_convert_widget_to_bin_window_coords:
10870 * @tree_view: a #PsppSheetView
10871 * @wx: X coordinate relative to the widget
10872 * @wy: Y coordinate relative to the widget
10873 * @bx: return location for bin_window X coordinate
10874 * @by: return location for bin_window Y coordinate
10875 *
10876 * Converts widget coordinates to coordinates for the bin_window
10877 * (see pspp_sheet_view_get_bin_window()).
10878 *
10879 * Since: 2.12
10880 **/
10881 void
10883 gint wx,
10884 gint wy,
10887 {
10894 }
10896 /**
10897 * pspp_sheet_view_convert_bin_window_to_widget_coords:
10898 * @tree_view: a #PsppSheetView
10899 * @bx: bin_window X coordinate
10900 * @by: bin_window Y coordinate
10901 * @wx: return location for widget X coordinate
10902 * @wy: return location for widget Y coordinate
10903 *
10904 * Converts bin_window coordinates (see pspp_sheet_view_get_bin_window())
10905 * to widget relative coordinates.
10906 *
10907 * Since: 2.12
10908 **/
10909 void
10911 gint bx,
10912 gint by,
10915 {
10922 }
10924 /**
10925 * pspp_sheet_view_convert_tree_to_bin_window_coords:
10926 * @tree_view: a #PsppSheetView
10927 * @tx: tree X coordinate
10928 * @ty: tree Y coordinate
10929 * @bx: return location for X coordinate relative to bin_window
10930 * @by: return location for Y coordinate relative to bin_window
10931 *
10932 * Converts tree coordinates (coordinates in full scrollable area of the tree)
10933 * to bin_window coordinates.
10934 *
10935 * Since: 2.12
10936 **/
10937 void
10939 gint tx,
10940 gint ty,
10943 {
10950 }
10952 /**
10953 * pspp_sheet_view_convert_bin_window_to_tree_coords:
10954 * @tree_view: a #PsppSheetView
10955 * @bx: X coordinate relative to bin_window
10956 * @by: Y coordinate relative to bin_window
10957 * @tx: return location for tree X coordinate
10958 * @ty: return location for tree Y coordinate
10959 *
10960 * Converts bin_window coordinates to coordinates for the
10961 * tree (the full scrollable area of the tree).
10962 *
10963 * Since: 2.12
10964 **/
10965 void
10967 gint bx,
10968 gint by,
10971 {
10978 }
10982 /**
10983 * pspp_sheet_view_get_visible_range:
10984 * @tree_view: A #PsppSheetView
10985 * @start_path: (allow-none): Return location for start of region, or %NULL.
10986 * @end_path: (allow-none): Return location for end of region, or %NULL.
10987 *
10988 * Sets @start_path and @end_path to be the first and last visible path.
10989 * Note that there may be invisible paths in between.
10990 *
10991 * The paths should be freed with gtk_tree_path_free() after use.
10992 *
10993 * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
10994 *
10995 * Since: 2.8
10996 **/
10997 gboolean
11001 {
11003 gboolean retval;
11013 {
11019 else
11021 }
11024 {
11025 gint y;
11029 else
11030 y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
11035 else
11037 }
11040 }
11042 static void
11044 {
11046 {
11049 }
11050 }
11052 /**
11053 * pspp_sheet_view_enable_model_drag_source:
11054 * @tree_view: a #PsppSheetView
11055 * @start_button_mask: Mask of allowed buttons to start drag
11056 * @targets: the table of targets that the drag will support
11057 * @n_targets: the number of items in @targets
11058 * @actions: the bitmask of possible actions for a drag from this
11059 * widget
11060 *
11061 * Turns @tree_view into a drag source for automatic DND. Calling this
11062 * method sets #PsppSheetView:reorderable to %FALSE.
11063 **/
11064 void
11066 GdkModifierType start_button_mask,
11068 gint n_targets,
11069 GdkDragAction actions)
11070 {
11077 targets,
11078 n_targets,
11079 actions);
11088 }
11090 /**
11091 * pspp_sheet_view_enable_model_drag_dest:
11092 * @tree_view: a #PsppSheetView
11093 * @targets: the table of targets that the drag will support
11094 * @n_targets: the number of items in @targets
11095 * @actions: the bitmask of possible actions for a drag from this
11096 * widget
11097 *
11098 * Turns @tree_view into a drop destination for automatic DND. Calling
11099 * this method sets #PsppSheetView:reorderable to %FALSE.
11100 **/
11101 void
11104 gint n_targets,
11105 GdkDragAction actions)
11106 {
11113 targets,
11114 n_targets,
11115 actions);
11121 }
11123 /**
11124 * pspp_sheet_view_unset_rows_drag_source:
11125 * @tree_view: a #PsppSheetView
11126 *
11127 * Undoes the effect of
11128 * pspp_sheet_view_enable_model_drag_source(). Calling this method sets
11129 * #PsppSheetView:reorderable to %FALSE.
11130 **/
11131 void
11133 {
11141 {
11143 {
11146 }
11150 }
11153 }
11155 /**
11156 * pspp_sheet_view_unset_rows_drag_dest:
11157 * @tree_view: a #PsppSheetView
11158 *
11159 * Undoes the effect of
11160 * pspp_sheet_view_enable_model_drag_dest(). Calling this method sets
11161 * #PsppSheetView:reorderable to %FALSE.
11162 **/
11163 void
11165 {
11173 {
11175 {
11178 }
11182 }
11185 }
11187 /**
11188 * pspp_sheet_view_set_drag_dest_row:
11189 * @tree_view: a #PsppSheetView
11190 * @path: (allow-none): The path of the row to highlight, or %NULL.
11191 * @pos: Specifies whether to drop before, after or into the row
11192 *
11193 * Sets the row that is highlighted for feedback.
11194 **/
11195 void
11198 PsppSheetViewDropPosition pos)
11199 {
11202 /* Note; this function is exported to allow a custom DND
11203 * implementation, so it can't touch TreeViewDragInfo
11204 */
11211 {
11214 }
11216 /* special case a drop on an empty model */
11222 {
11223 gint n_children;
11226 NULL);
11230 }
11235 {
11239 }
11240 else
11244 {
11251 {
11259 }
11261 }
11262 }
11264 /**
11265 * pspp_sheet_view_get_drag_dest_row:
11266 * @tree_view: a #PsppSheetView
11267 * @path: (allow-none): Return location for the path of the highlighted row, or %NULL.
11268 * @pos: (allow-none): Return location for the drop position, or %NULL
11269 *
11270 * Gets information about the row that is highlighted for feedback.
11271 **/
11272 void
11276 {
11280 {
11283 else
11284 {
11287 else
11289 }
11290 }
11294 }
11296 /**
11297 * pspp_sheet_view_get_dest_row_at_pos:
11298 * @tree_view: a #PsppSheetView
11299 * @drag_x: the position to determine the destination row for
11300 * @drag_y: the position to determine the destination row for
11301 * @path: (allow-none): Return location for the path of the highlighted row, or %NULL.
11302 * @pos: (allow-none): Return location for the drop position, or %NULL
11303 *
11304 * Determines the destination row for a given position. @drag_x and
11305 * @drag_y are expected to be in widget coordinates. This function is only
11306 * meaningful if @tree_view is realized. Therefore this function will always
11307 * return %FALSE if @tree_view is not realized or does not have a model.
11308 *
11309 * Return value: whether there is a row at the given position, %TRUE if this
11310 * is indeed the case.
11311 **/
11312 gboolean
11314 gint drag_x,
11315 gint drag_y,
11318 {
11319 gint cell_y;
11321 gdouble offset_into_row;
11322 gdouble third;
11323 GdkRectangle cell;
11327 /* Note; this function is exported to allow a custom DND
11328 * implementation, so it can't touch TreeViewDragInfo
11329 */
11344 /* If in the top third of a row, we drop before that row; if
11345 * in the bottom third, drop after that row; if in the middle,
11346 * and the row has children, drop into the row.
11347 */
11352 bin_x,
11353 bin_y,
11356 NULL,
11367 else
11375 {
11377 {
11379 }
11381 {
11383 }
11385 {
11387 }
11388 else
11389 {
11391 }
11392 }
11395 }
11398 #if GTK3_TRANSITION
11399 /* KEEP IN SYNC WITH PSPP_SHEET_VIEW_BIN_EXPOSE */
11400 /**
11401 * pspp_sheet_view_create_row_drag_icon:
11402 * @tree_view: a #PsppSheetView
11403 * @path: a #GtkTreePath in @tree_view
11404 *
11405 * Creates a #GdkPixmap representation of the row at @path.
11406 * This image is used for a drag icon.
11407 *
11408 * Return value: a newly-allocated pixmap of the drag icon.
11409 **/
11410 GdkPixmap *
11413 {
11414 GtkTreeIter iter;
11416 gint cell_offset;
11418 GdkRectangle background_area;
11419 GdkRectangle expose_area;
11421 /* start drawing inside the black outline */
11424 gint bin_window_width;
11425 gboolean rtl;
11436 path,
11444 path))
11464 #if GTK3_TRANSITION
11467 TRUE,
11471 #endif
11475 for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
11476 list;
11478 {
11480 GdkRectangle cell_area;
11481 gint vertical_separator;
11493 NULL);
11502 drawable,
11508 }
11510 #if GTK3_TRANSITION
11513 FALSE,
11517 #endif
11520 }
11521 #endif
11523 /**
11524 * pspp_sheet_view_set_destroy_count_func:
11525 * @tree_view: A #PsppSheetView
11526 * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
11527 * @data: (allow-none): User data to be passed to @func, or %NULL
11528 * @destroy: (allow-none): Destroy notifier for @data, or %NULL
11529 *
11530 * This function should almost never be used. It is meant for private use by
11531 * ATK for determining the number of visible children that are removed when a row is deleted.
11532 **/
11533 void
11535 PsppSheetDestroyCountFunc func,
11536 gpointer data,
11537 GDestroyNotify destroy)
11538 {
11547 }
11550 /*
11551 * Interactive search
11552 */
11554 /**
11555 * pspp_sheet_view_set_enable_search:
11556 * @tree_view: A #PsppSheetView
11557 * @enable_search: %TRUE, if the user can search interactively
11558 *
11559 * If @enable_search is set, then the user can type in text to search through
11560 * the tree interactively (this is sometimes called "typeahead find").
11561 *
11562 * Note that even if this is %FALSE, the user can still initiate a search
11563 * using the "start-interactive-search" key binding.
11564 */
11565 void
11567 gboolean enable_search)
11568 {
11574 {
11577 }
11578 }
11580 /**
11581 * pspp_sheet_view_get_enable_search:
11582 * @tree_view: A #PsppSheetView
11583 *
11584 * Returns whether or not the tree allows to start interactive searching
11585 * by typing in text.
11586 *
11587 * Return value: whether or not to let the user search interactively
11588 */
11589 gboolean
11591 {
11595 }
11598 /**
11599 * pspp_sheet_view_get_search_column:
11600 * @tree_view: A #PsppSheetView
11601 *
11602 * Gets the column searched on by the interactive search code.
11603 *
11604 * Return value: the column the interactive search code searches in.
11605 */
11606 gint
11608 {
11612 }
11614 /**
11615 * pspp_sheet_view_set_search_column:
11616 * @tree_view: A #PsppSheetView
11617 * @column: the column of the model to search in, or -1 to disable searching
11618 *
11619 * Sets @column as the column where the interactive search code should
11620 * search in for the current model.
11621 *
11622 * If the search column is set, users can use the "start-interactive-search"
11623 * key binding to bring up search popup. The enable-search property controls
11624 * whether simply typing text will also start an interactive search.
11625 *
11626 * Note that @column refers to a column of the current model. The search
11627 * column is reset to -1 when the model is changed.
11628 */
11629 void
11631 gint column)
11632 {
11641 }
11643 /**
11644 * pspp_sheet_view_get_search_equal_func:
11645 * @tree_view: A #PsppSheetView
11646 *
11647 * Returns the compare function currently in use.
11648 *
11649 * Return value: the currently used compare function for the search code.
11650 */
11652 PsppSheetViewSearchEqualFunc
11654 {
11658 }
11660 /**
11661 * pspp_sheet_view_set_search_equal_func:
11662 * @tree_view: A #PsppSheetView
11663 * @search_equal_func: the compare function to use during the search
11664 * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
11665 * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
11666 *
11667 * Sets the compare function for the interactive search capabilities; note
11668 * that somewhat like strcmp() returning 0 for equality
11669 * #PsppSheetViewSearchEqualFunc returns %FALSE on matches.
11670 **/
11671 void
11673 PsppSheetViewSearchEqualFunc search_equal_func,
11674 gpointer search_user_data,
11675 GDestroyNotify search_destroy)
11676 {
11688 }
11690 /**
11691 * pspp_sheet_view_get_search_entry:
11692 * @tree_view: A #PsppSheetView
11693 *
11694 * Returns the #GtkEntry which is currently in use as interactive search
11695 * entry for @tree_view. In case the built-in entry is being used, %NULL
11696 * will be returned.
11697 *
11698 * Return value: the entry currently in use as search entry.
11699 *
11700 * Since: 2.10
11701 */
11702 GtkEntry *
11704 {
11711 }
11713 /**
11714 * pspp_sheet_view_set_search_entry:
11715 * @tree_view: A #PsppSheetView
11716 * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
11717 *
11718 * Sets the entry which the interactive search code will use for this
11719 * @tree_view. This is useful when you want to provide a search entry
11720 * in our interface at all time at a fixed position. Passing %NULL for
11721 * @entry will make the interactive search code use the built-in popup
11722 * entry again.
11723 *
11724 * Since: 2.10
11725 */
11726 void
11729 {
11734 {
11736 {
11740 }
11743 tree_view);
11746 }
11748 {
11752 }
11755 {
11760 {
11764 tree_view);
11765 }
11769 tree_view);
11772 }
11773 else
11774 {
11777 }
11778 }
11780 /**
11781 * pspp_sheet_view_set_search_position_func:
11782 * @tree_view: A #PsppSheetView
11783 * @func: (allow-none): the function to use to position the search dialog, or %NULL
11784 * to use the default search position function
11785 * @data: (allow-none): user data to pass to @func, or %NULL
11786 * @destroy: (allow-none): Destroy notifier for @data, or %NULL
11787 *
11788 * Sets the function to use when positioning the search dialog.
11789 *
11790 * Since: 2.10
11791 **/
11792 void
11794 PsppSheetViewSearchPositionFunc func,
11795 gpointer user_data,
11796 GDestroyNotify destroy)
11797 {
11808 }
11810 /**
11811 * pspp_sheet_view_get_search_position_func:
11812 * @tree_view: A #PsppSheetView
11813 *
11814 * Returns the positioning function currently in use.
11815 *
11816 * Return value: the currently used function for positioning the search dialog.
11817 *
11818 * Since: 2.10
11819 */
11820 PsppSheetViewSearchPositionFunc
11822 {
11826 }
11829 static void
11832 {
11837 {
11841 }
11843 {
11846 }
11849 {
11850 /* send focus-in event */
11855 }
11856 }
11858 static void
11861 gpointer user_data)
11862 {
11868 GtkRequisition requisition;
11869 gint monitor_num;
11870 GdkRectangle monitor;
11887 else
11894 else
11898 }
11900 static void
11903 gpointer data)
11904 {
11910 }
11912 #if GTK3_TRANSITION
11913 /* Because we're visible but offscreen, we just set a flag in the preedit
11914 * callback.
11915 */
11916 static void
11919 {
11922 {
11927 tree_view);
11928 }
11930 }
11931 #endif
11933 static void
11936 {
11941 tree_view);
11943 /* If we have a row selected and it's the cursor row, we activate
11944 * the row XXX */
11946 {
11955 }
11956 }
11958 static gboolean
11960 {
11966 }
11968 static void
11970 gpointer data)
11971 {
11972 gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, pspp_sheet_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
11973 }
11975 static gboolean
11979 {
11985 }
11987 static gboolean
11991 {
12000 }
12002 static gboolean
12006 {
12010 {
12013 }
12015 {
12018 }
12020 /* renew the flush timeout */
12023 {
12028 tree_view);
12029 }
12032 }
12034 static gboolean
12038 {
12044 /* close window and cancel the search */
12050 {
12053 }
12055 /* select previous matching iter */
12057 {
12062 }
12064 if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK))
12066 {
12071 }
12073 /* select next matching iter */
12075 {
12080 }
12082 if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == GTK_DEFAULT_ACCEL_MOD_MASK)
12084 {
12089 }
12091 /* renew the flush timeout */
12094 {
12099 tree_view);
12100 }
12103 }
12105 /* this function returns FALSE if there is a search string but
12106 * nothing was found, and TRUE otherwise.
12107 */
12108 static gboolean
12111 gboolean up)
12112 {
12113 gboolean ret;
12114 gint len;
12117 GtkTreeIter iter;
12138 /* search */
12147 {
12148 /* found */
12151 }
12152 else
12153 {
12154 /* return to old iter */
12161 }
12162 }
12164 static gboolean
12166 gint column,
12169 gpointer search_data)
12170 {
12185 {
12188 }
12194 {
12197 }
12203 {
12209 }
12218 }
12220 static gboolean
12226 gint n)
12227 {
12236 do
12237 {
12240 if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
12241 {
12244 {
12254 }
12255 }
12258 do
12259 {
12263 {
12264 gboolean has_next;
12271 /* sanity check */
12273 }
12274 else
12275 {
12279 /* we've run out of tree, done with this func */
12281 }
12282 }
12284 }
12288 }
12290 static void
12293 {
12294 gint ret;
12297 GtkTreeIter iter;
12309 /* search */
12313 {
12318 tree_view);
12319 }
12333 }
12335 static void
12338 {
12349 pspp_sheet_view_remove_widget,
12350 tree_view);
12352 pspp_sheet_view_editable_button_press_event,
12353 tree_view);
12355 pspp_sheet_view_editable_clicked,
12356 tree_view);
12361 /* FIXME should only redraw a single node */
12363 }
12365 static gboolean
12368 {
12369 GtkTreeIter iter;
12370 GdkRectangle background_area;
12371 GdkRectangle cell_area;
12394 cursor_path,
12398 cursor_path,
12404 NULL,
12405 path_string,
12408 flags))
12409 {
12412 {
12414 GdkRectangle area;
12420 _pspp_sheet_view_column_get_neighbor_sizes (tree_view->priv->focus_column, cell, &left, &right);
12427 cursor_path,
12428 editable_widget,
12430 NULL,
12431 flags);
12432 }
12434 }
12437 }
12439 static gboolean
12443 {
12444 gint node;
12449 node,
12451 event);
12452 }
12454 static void
12457 {
12459 sheet_view);
12460 }
12462 static gboolean
12464 {
12476 }
12478 static gboolean
12480 {
12483 }
12485 static gboolean
12487 {
12489 gint length;
12497 }
12499 static gboolean
12503 {
12506 gboolean handled;
12507 gboolean cancel;
12508 guint keyval;
12509 gint row;
12511 /* Intercept only key press events.
12512 It would make sense to use "key-press-event" instead of "event", but
12513 GtkEntry attaches its own signal handler to "key-press-event" that runs
12514 before ours and overrides our desired behavior for GDK_Up and GDK_Down.
12515 */
12522 {
12525 {
12561 }
12566 {
12574 }
12579 {
12596 }
12601 }
12623 }
12625 static void
12627 gpointer data)
12628 {
12633 sheet_view);
12637 pspp_sheet_view_override_cell_keypresses,
12638 data);
12639 }
12641 static void
12648 guint flags)
12649 {
12652 GtkRequisition requisition;
12653 gint row;
12674 {
12680 }
12681 else
12682 {
12687 }
12697 {
12700 tree_view);
12705 tree_view);
12706 }
12709 tree_view);
12710 }
12712 void
12714 gboolean cancel_editing)
12715 {
12722 /*
12723 * This is very evil. We need to do this, because
12724 * gtk_cell_editable_editing_done may trigger pspp_sheet_view_row_changed
12725 * later on. If pspp_sheet_view_row_changed notices
12726 * tree_view->priv->edited_column != NULL, it'll call
12727 * pspp_sheet_view_stop_editing again. Bad things will happen then.
12728 *
12729 * Please read that again if you intend to modify anything here.
12730 */
12744 }
12747 /**
12748 * pspp_sheet_view_set_hover_selection:
12749 * @tree_view: a #PsppSheetView
12750 * @hover: %TRUE to enable hover selection mode
12751 *
12752 * Enables of disables the hover selection mode of @tree_view.
12753 * Hover selection makes the selected row follow the pointer.
12754 * Currently, this works only for the selection modes
12755 * %PSPP_SHEET_SELECTION_SINGLE and %PSPP_SHEET_SELECTION_BROWSE.
12756 *
12757 * Since: 2.6
12758 **/
12759 void
12761 gboolean hover)
12762 {
12766 {
12770 }
12771 }
12773 /**
12774 * pspp_sheet_view_get_hover_selection:
12775 * @tree_view: a #PsppSheetView
12776 *
12777 * Returns whether hover selection mode is turned on for @tree_view.
12778 *
12779 * Return value: %TRUE if @tree_view is in hover selection mode
12780 *
12781 * Since: 2.6
12782 **/
12783 gboolean
12785 {
12787 }
12789 /**
12790 * pspp_sheet_view_set_rubber_banding:
12791 * @tree_view: a #PsppSheetView
12792 * @enable: %TRUE to enable rubber banding
12793 *
12794 * Enables or disables rubber banding in @tree_view. If the selection mode is
12795 * #PSPP_SHEET_SELECTION_MULTIPLE or #PSPP_SHEET_SELECTION_RECTANGLE, rubber
12796 * banding will allow the user to select multiple rows by dragging the mouse.
12797 *
12798 * Since: 2.10
12799 **/
12800 void
12802 gboolean enable)
12803 {
12807 {
12811 }
12812 }
12814 /**
12815 * pspp_sheet_view_get_rubber_banding:
12816 * @tree_view: a #PsppSheetView
12817 *
12818 * Returns whether rubber banding is turned on for @tree_view. If the
12819 * selection mode is #PSPP_SHEET_SELECTION_MULTIPLE or
12820 * #PSPP_SHEET_SELECTION_RECTANGLE, rubber banding will allow the user to
12821 * select multiple rows by dragging the mouse.
12822 *
12823 * Return value: %TRUE if rubber banding in @tree_view is enabled.
12824 *
12825 * Since: 2.10
12826 **/
12827 gboolean
12829 {
12831 }
12833 /**
12834 * pspp_sheet_view_is_rubber_banding_active:
12835 * @tree_view: a #PsppSheetView
12836 *
12837 * Returns whether a rubber banding operation is currently being done
12838 * in @tree_view.
12839 *
12840 * Return value: %TRUE if a rubber banding operation is currently being
12841 * done in @tree_view.
12842 *
12843 * Since: 2.12
12844 **/
12845 gboolean
12847 {
12855 }
12857 static void
12859 gboolean was_grabbed)
12860 {
12866 {
12871 }
12872 }
12874 static void
12876 GtkStateType previous_state)
12877 {
12881 {
12883 gdk_window_set_background (tree_view->priv->bin_window, &style->base[gtk_widget_get_state (widget)]);
12884 }
12887 }
12889 /**
12890 * pspp_sheet_view_get_grid_lines:
12891 * @tree_view: a #PsppSheetView
12892 *
12893 * Returns which grid lines are enabled in @tree_view.
12894 *
12895 * Return value: a #PsppSheetViewGridLines value indicating which grid lines
12896 * are enabled.
12897 *
12898 * Since: 2.10
12899 */
12900 PsppSheetViewGridLines
12902 {
12906 }
12908 /**
12909 * pspp_sheet_view_set_grid_lines:
12910 * @tree_view: a #PsppSheetView
12911 * @grid_lines: a #PsppSheetViewGridLines value indicating which grid lines to
12912 * enable.
12913 *
12914 * Sets which grid lines to draw in @tree_view.
12915 *
12916 * Since: 2.10
12917 */
12918 void
12920 PsppSheetViewGridLines grid_lines)
12921 {
12923 PsppSheetViewGridLines old_grid_lines;
12933 {
12937 }
12938 }
12940 /**
12941 * pspp_sheet_view_get_special_cells:
12942 * @tree_view: a #PsppSheetView
12943 *
12944 * Returns which grid lines are enabled in @tree_view.
12945 *
12946 * Return value: a #PsppSheetViewSpecialCells value indicating whether rows in
12947 * the sheet view contain special cells.
12948 */
12949 PsppSheetViewSpecialCells
12951 {
12955 }
12957 /**
12958 * pspp_sheet_view_set_special_cells:
12959 * @tree_view: a #PsppSheetView
12960 * @special_cells: a #PsppSheetViewSpecialCells value indicating whether rows in
12961 * the sheet view contain special cells.
12962 *
12963 * Sets whether rows in the sheet view contain special cells, controlling the
12964 * rendering of row selections.
12965 */
12966 void
12968 PsppSheetViewSpecialCells special_cells)
12969 {
12977 {
12981 }
12982 }
12984 int
12986 {
12987 /* XXX (re)calculate fixed_height if necessary */
12989 }
12991 void
12994 {
12998 {
13001 }
13003 {
13006 }
13007 }
13009 /**
13010 * pspp_sheet_view_set_tooltip_row:
13011 * @tree_view: a #PsppSheetView
13012 * @tooltip: a #GtkTooltip
13013 * @path: a #GtkTreePath
13014 *
13015 * Sets the tip area of @tooltip to be the area covered by the row at @path.
13016 * See also pspp_sheet_view_set_tooltip_column() for a simpler alternative.
13017 * See also gtk_tooltip_set_tip_area().
13018 *
13019 * Since: 2.12
13020 */
13021 void
13025 {
13030 }
13032 /**
13033 * pspp_sheet_view_set_tooltip_cell:
13034 * @tree_view: a #PsppSheetView
13035 * @tooltip: a #GtkTooltip
13036 * @path: (allow-none): a #GtkTreePath or %NULL
13037 * @column: (allow-none): a #PsppSheetViewColumn or %NULL
13038 * @cell: (allow-none): a #GtkCellRenderer or %NULL
13039 *
13040 * Sets the tip area of @tooltip to the area @path, @column and @cell have
13041 * in common. For example if @path is %NULL and @column is set, the tip
13042 * area will be set to the full area covered by @column. See also
13043 * gtk_tooltip_set_tip_area().
13044 *
13045 * See also pspp_sheet_view_set_tooltip_column() for a simpler alternative.
13046 *
13047 * Since: 2.12
13048 */
13049 void
13055 {
13056 GdkRectangle rect;
13063 /* Determine x values. */
13065 {
13066 GdkRectangle tmp;
13076 }
13078 {
13079 GdkRectangle tmp;
13086 }
13087 else
13088 {
13089 GtkAllocation allocation;
13093 }
13095 /* Determine y values. */
13097 {
13098 GdkRectangle tmp;
13105 }
13106 else
13107 {
13110 }
13113 }
13115 /**
13116 * pspp_sheet_view_get_tooltip_context:
13117 * @tree_view: a #PsppSheetView
13118 * @x: the x coordinate (relative to widget coordinates)
13119 * @y: the y coordinate (relative to widget coordinates)
13120 * @keyboard_tip: whether this is a keyboard tooltip or not
13121 * @model: (allow-none): a pointer to receive a #GtkTreeModel or %NULL
13122 * @path: (allow-none): a pointer to receive a #GtkTreePath or %NULL
13123 * @iter: (allow-none): a pointer to receive a #GtkTreeIter or %NULL
13124 *
13125 * This function is supposed to be used in a #GtkWidget::query-tooltip
13126 * signal handler for #PsppSheetView. The @x, @y and @keyboard_tip values
13127 * which are received in the signal handler, should be passed to this
13128 * function without modification.
13129 *
13130 * The return value indicates whether there is a tree view row at the given
13131 * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
13132 * tooltips the row returned will be the cursor row. When %TRUE, then any of
13133 * @model, @path and @iter which have been provided will be set to point to
13134 * that row and the corresponding model. @x and @y will always be converted
13135 * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
13136 *
13137 * Return value: whether or not the given tooltip context points to a row.
13138 *
13139 * Since: 2.12
13140 */
13141 gboolean
13145 gboolean keyboard_tip,
13149 {
13157 {
13162 }
13163 else
13164 {
13171 }
13182 else
13186 }
13188 static gboolean
13190 gint x,
13191 gint y,
13192 gboolean keyboard_tip,
13194 gpointer data)
13195 {
13198 GtkTreeIter iter;
13205 keyboard_tip,
13215 {
13220 }
13225 {
13230 }
13239 }
13241 /**
13242 * pspp_sheet_view_set_tooltip_column:
13243 * @tree_view: a #PsppSheetView
13244 * @column: an integer, which is a valid column number for @tree_view's model
13245 *
13246 * If you only plan to have simple (text-only) tooltips on full rows, you
13247 * can use this function to have #PsppSheetView handle these automatically
13248 * for you. @column should be set to the column in @tree_view's model
13249 * containing the tooltip texts, or -1 to disable this feature.
13250 *
13251 * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
13252 * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
13253 *
13254 * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
13255 * so &, <, etc have to be escaped in the text.
13256 *
13257 * Since: 2.12
13258 */
13259 void
13261 gint column)
13262 {
13269 {
13271 pspp_sheet_view_set_tooltip_query_cb,
13272 NULL);
13274 }
13275 else
13276 {
13278 {
13282 }
13283 }
13287 }
13289 /**
13290 * pspp_sheet_view_get_tooltip_column:
13291 * @tree_view: a #PsppSheetView
13292 *
13293 * Returns the column of @tree_view's model which is being used for
13294 * displaying tooltips on @tree_view's rows.
13295 *
13296 * Return value: the index of the tooltip column that is currently being
13297 * used, or -1 if this is disabled.
13298 *
13299 * Since: 2.12
13300 */
13301 gint
13303 {
13307 }
13309 gboolean
13313 gpointer dummy)
13314 {
13315 gboolean continue_emission;
13316 gboolean signal_handled;
13323 }
13326 GType
13328 {
13333 { PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL, "PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL", "horizontal" },
13337 };
13339 }
13341 }
13343 GType
13345 {
13353 };
13354 etype = g_enum_register_static (g_intern_static_string ("PsppSheetViewSpecialCells"), values);
13355 }
13357 }