« back to all changes in this revision
Viewing changes to src/egg-list-box.c
- browse files at revision 17
- compare with another revision
- download diff
- download tarball
- view history from revision 17
- Committer: Package Import Robot
- Author(s): Matthew Fischer
- Date: 2013-05-23 19:36:13 UTC
- mfrom: (1.1.13)
- Revision ID: package-import@ubuntu.com-20130523193613-6wrnnsmgwidm86c3
Tags: 3.8.2-0ubuntu1
* New upstream release (LP: #1181921)
* Use a menu button instead of toolbar items
* Update to the latest libgd and egglistbox
* Add an High Contrast icon
* Use the newest libgd to animate tranistion to and from the results
page
* Minor bugfixes
* Use a menu button instead of toolbar items
* Update to the latest libgd and egglistbox
* Add an High Contrast icon
* Use the newest libgd to animate tranistion to and from the results
page
* Minor bugfixes
- files added:
- debian/bzr-builddeb.conf
- egg-list-box
- files removed:
- libgd/libgd/gd-main-toolbar.c
- files modified:
- ChangeLog
added
removed
src/egg-list-box.c
1
/*
2
* Copyright (C) 2012 Alexander Larsson <alexl@redhat.com>
3
*
4
* This library is free software; you can redistribute it and/or
5
* modify it under the terms of the GNU Lesser General Public
6
* License as published by the Free Software Foundation; either
7
* version 2 of the License, or (at your option) any later version.
8
*
9
* This library 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 GNU
12
* Lesser General Public License for more details.
13
*
14
* You should have received a copy of the GNU Lesser General Public
15
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
16
*/
17
18
#include <glib.h>
19
#include <glib-object.h>
20
#include <gtk/gtk.h>
21
#include <gdk/gdk.h>
22
#include <float.h>
23
#include <math.h>
24
#include <cairo.h>
25
#include <string.h>
26
#include <gobject/gvaluecollector.h>
27
28
#include "egg-list-box.h"
29
30
/* This already exists in gtk as _gtk_marshal_VOID__ENUM_INT, inline it here for now
31
to avoid separate marshallers file */
32
static void
33
_egg_marshal_VOID__ENUM_INT (GClosure * closure,
34
GValue * return_value,
35
guint n_param_values,
36
const GValue * param_values,
37
gpointer invocation_hint,
38
gpointer marshal_data)
39
{
40
typedef void (*GMarshalFunc_VOID__ENUM_INT) (gpointer data1, gint arg_1, gint arg_2, gpointer data2);
41
register GMarshalFunc_VOID__ENUM_INT callback;
42
register GCClosure * cc;
43
register gpointer data1;
44
register gpointer data2;
45
cc = (GCClosure *) closure;
46
g_return_if_fail (n_param_values == 3);
47
if (G_CCLOSURE_SWAP_DATA (closure)) {
48
data1 = closure->data;
49
data2 = param_values->data[0].v_pointer;
50
} else {
51
data1 = param_values->data[0].v_pointer;
52
data2 = closure->data;
53
}
54
callback = (GMarshalFunc_VOID__ENUM_INT) (marshal_data ? marshal_data : cc->callback);
55
callback (data1, g_value_get_enum (param_values + 1), g_value_get_int (param_values + 2), data2);
56
}
57
58
typedef struct _EggListBoxChildInfo EggListBoxChildInfo;
59
60
struct _EggListBoxPrivate
61
{
62
GSequence *children;
63
GHashTable *child_hash;
64
GHashTable *separator_hash;
65
66
GCompareDataFunc sort_func;
67
gpointer sort_func_target;
68
GDestroyNotify sort_func_target_destroy_notify;
69
70
EggListBoxFilterFunc filter_func;
71
gpointer filter_func_target;
72
GDestroyNotify filter_func_target_destroy_notify;
73
74
EggListBoxUpdateSeparatorFunc update_separator_func;
75
gpointer update_separator_func_target;
76
GDestroyNotify update_separator_func_target_destroy_notify;
77
78
EggListBoxChildInfo *selected_child;
79
EggListBoxChildInfo *prelight_child;
80
EggListBoxChildInfo *cursor_child;
81
82
gboolean active_child_active;
83
EggListBoxChildInfo *active_child;
84
85
GtkSelectionMode selection_mode;
86
87
GtkAdjustment *adjustment;
88
gboolean activate_single_click;
89
90
/* DnD */
91
GtkWidget *drag_highlighted_widget;
92
guint auto_scroll_timeout_id;
93
};
94
95
struct _EggListBoxChildInfo
96
{
97
GSequenceIter *iter;
98
GtkWidget *widget;
99
GtkWidget *separator;
100
gint y;
101
gint height;
102
};
103
104
enum {
105
CHILD_SELECTED,
106
CHILD_ACTIVATED,
107
ACTIVATE_CURSOR_CHILD,
108
TOGGLE_CURSOR_CHILD,
109
MOVE_CURSOR,
110
LAST_SIGNAL
111
};
112
113
enum {
114
PROP_0
115
};
116
117
G_DEFINE_TYPE (EggListBox, egg_list_box, GTK_TYPE_CONTAINER)
118
119
static EggListBoxChildInfo *egg_list_box_find_child_at_y (EggListBox *list_box,
120
gint y);
121
static EggListBoxChildInfo *egg_list_box_lookup_info (EggListBox *list_box,
122
GtkWidget *widget);
123
static void egg_list_box_update_selected (EggListBox *list_box,
124
EggListBoxChildInfo *child);
125
static void egg_list_box_apply_filter_all (EggListBox *list_box);
126
static void egg_list_box_update_separator (EggListBox *list_box,
127
GSequenceIter *iter);
128
static GSequenceIter * egg_list_box_get_next_visible (EggListBox *list_box,
129
GSequenceIter *_iter);
130
static void egg_list_box_apply_filter (EggListBox *list_box,
131
GtkWidget *child);
132
static void egg_list_box_add_move_binding (GtkBindingSet *binding_set,
133
guint keyval,
134
GdkModifierType modmask,
135
GtkMovementStep step,
136
gint count);
137
static void egg_list_box_update_cursor (EggListBox *list_box,
138
EggListBoxChildInfo *child);
139
static void egg_list_box_select_and_activate (EggListBox *list_box,
140
EggListBoxChildInfo *child);
141
static void egg_list_box_update_prelight (EggListBox *list_box,
142
EggListBoxChildInfo *child);
143
static void egg_list_box_update_active (EggListBox *list_box,
144
EggListBoxChildInfo *child);
145
static gboolean egg_list_box_real_enter_notify_event (GtkWidget *widget,
146
GdkEventCrossing *event);
147
static gboolean egg_list_box_real_leave_notify_event (GtkWidget *widget,
148
GdkEventCrossing *event);
149
static gboolean egg_list_box_real_motion_notify_event (GtkWidget *widget,
150
GdkEventMotion *event);
151
static gboolean egg_list_box_real_button_press_event (GtkWidget *widget,
152
GdkEventButton *event);
153
static gboolean egg_list_box_real_button_release_event (GtkWidget *widget,
154
GdkEventButton *event);
155
static void egg_list_box_real_show (GtkWidget *widget);
156
static gboolean egg_list_box_real_focus (GtkWidget *widget,
157
GtkDirectionType direction);
158
static GSequenceIter* egg_list_box_get_previous_visible (EggListBox *list_box,
159
GSequenceIter *_iter);
160
static EggListBoxChildInfo *egg_list_box_get_first_visible (EggListBox *list_box);
161
static EggListBoxChildInfo *egg_list_box_get_last_visible (EggListBox *list_box);
162
static gboolean egg_list_box_real_draw (GtkWidget *widget,
163
cairo_t *cr);
164
static void egg_list_box_real_realize (GtkWidget *widget);
165
static void egg_list_box_real_add (GtkContainer *container,
166
GtkWidget *widget);
167
static void egg_list_box_real_remove (GtkContainer *container,
168
GtkWidget *widget);
169
static void egg_list_box_real_forall_internal (GtkContainer *container,
170
gboolean include_internals,
171
GtkCallback callback,
172
void *callback_target);
173
static void egg_list_box_real_compute_expand_internal (GtkWidget *widget,
174
gboolean *hexpand,
175
gboolean *vexpand);
176
static GType egg_list_box_real_child_type (GtkContainer *container);
177
static GtkSizeRequestMode egg_list_box_real_get_request_mode (GtkWidget *widget);
178
static void egg_list_box_real_size_allocate (GtkWidget *widget,
179
GtkAllocation *allocation);
180
static void egg_list_box_real_drag_leave (GtkWidget *widget,
181
GdkDragContext *context,
182
guint time_);
183
static gboolean egg_list_box_real_drag_motion (GtkWidget *widget,
184
GdkDragContext *context,
185
gint x,
186
gint y,
187
guint time_);
188
static void egg_list_box_real_activate_cursor_child (EggListBox *list_box);
189
static void egg_list_box_real_toggle_cursor_child (EggListBox *list_box);
190
static void egg_list_box_real_move_cursor (EggListBox *list_box,
191
GtkMovementStep step,
192
gint count);
193
static void egg_list_box_finalize (GObject *obj);
194
195
196
static void egg_list_box_real_get_preferred_height (GtkWidget *widget,
197
gint *minimum_height,
198
gint *natural_height);
199
static void egg_list_box_real_get_preferred_height_for_width (GtkWidget *widget,
200
gint width,
201
gint *minimum_height,
202
gint *natural_height);
203
static void egg_list_box_real_get_preferred_width (GtkWidget *widget,
204
gint *minimum_width,
205
gint *natural_width);
206
static void egg_list_box_real_get_preferred_width_for_height (GtkWidget *widget,
207
gint height,
208
gint *minimum_width,
209
gint *natural_width);
210
211
static guint signals[LAST_SIGNAL] = { 0 };
212
213
static EggListBoxChildInfo*
214
egg_list_box_child_info_new (GtkWidget *widget)
215
{
216
EggListBoxChildInfo *info;
217
218
info = g_new0 (EggListBoxChildInfo, 1);
219
info->widget = g_object_ref (widget);
220
return info;
221
}
222
223
static void
224
egg_list_box_child_info_free (EggListBoxChildInfo *info)
225
{
226
g_clear_object (&info->widget);
227
g_clear_object (&info->separator);
228
g_free (info);
229
}
230
231
EggListBox*
232
egg_list_box_new (void)
233
{
234
return g_object_new (EGG_TYPE_LIST_BOX, NULL);
235
}
236
237
static void
238
egg_list_box_init (EggListBox *list_box)
239
{
240
EggListBoxPrivate *priv;
241
242
list_box->priv = priv =
243
G_TYPE_INSTANCE_GET_PRIVATE (list_box, EGG_TYPE_LIST_BOX, EggListBoxPrivate);
244
245
gtk_widget_set_can_focus (GTK_WIDGET (list_box), TRUE);
246
gtk_widget_set_has_window (GTK_WIDGET (list_box), TRUE);
247
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (list_box), TRUE);
248
priv->selection_mode = GTK_SELECTION_SINGLE;
249
priv->activate_single_click = TRUE;
250
251
priv->children = g_sequence_new ((GDestroyNotify)egg_list_box_child_info_free);
252
priv->child_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, NULL);
253
priv->separator_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, NULL);
254
}
255
256
static void
257
egg_list_box_finalize (GObject *obj)
258
{
259
EggListBox *list_box = EGG_LIST_BOX (obj);
260
EggListBoxPrivate *priv = list_box->priv;
261
262
if (priv->auto_scroll_timeout_id != ((guint) 0))
263
g_source_remove (priv->auto_scroll_timeout_id);
264
265
if (priv->sort_func_target_destroy_notify != NULL)
266
priv->sort_func_target_destroy_notify (priv->sort_func_target);
267
if (priv->filter_func_target_destroy_notify != NULL)
268
priv->filter_func_target_destroy_notify (priv->filter_func_target);
269
if (priv->update_separator_func_target_destroy_notify != NULL)
270
priv->update_separator_func_target_destroy_notify (priv->update_separator_func_target);
271
272
g_clear_object (&priv->adjustment);
273
g_clear_object (&priv->drag_highlighted_widget);
274
275
g_sequence_free (priv->children);
276
g_hash_table_unref (priv->child_hash);
277
g_hash_table_unref (priv->separator_hash);
278
279
G_OBJECT_CLASS (egg_list_box_parent_class)->finalize (obj);
280
}
281
282
static void
283
egg_list_box_class_init (EggListBoxClass *klass)
284
{
285
GObjectClass *object_class = G_OBJECT_CLASS (klass);
286
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
287
GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
288
GtkBindingSet *binding_set;
289
290
egg_list_box_parent_class = g_type_class_peek_parent (klass);
291
292
g_type_class_add_private (klass, sizeof (EggListBoxPrivate));
293
294
object_class->finalize = egg_list_box_finalize;
295
widget_class->enter_notify_event = egg_list_box_real_enter_notify_event;
296
widget_class->leave_notify_event = egg_list_box_real_leave_notify_event;
297
widget_class->motion_notify_event = egg_list_box_real_motion_notify_event;
298
widget_class->button_press_event = egg_list_box_real_button_press_event;
299
widget_class->button_release_event = egg_list_box_real_button_release_event;
300
widget_class->show = egg_list_box_real_show;
301
widget_class->focus = egg_list_box_real_focus;
302
widget_class->draw = egg_list_box_real_draw;
303
widget_class->realize = egg_list_box_real_realize;
304
widget_class->compute_expand = egg_list_box_real_compute_expand_internal;
305
widget_class->get_request_mode = egg_list_box_real_get_request_mode;
306
widget_class->get_preferred_height = egg_list_box_real_get_preferred_height;
307
widget_class->get_preferred_height_for_width = egg_list_box_real_get_preferred_height_for_width;
308
widget_class->get_preferred_width = egg_list_box_real_get_preferred_width;
309
widget_class->get_preferred_width_for_height = egg_list_box_real_get_preferred_width_for_height;
310
widget_class->size_allocate = egg_list_box_real_size_allocate;
311
widget_class->drag_leave = egg_list_box_real_drag_leave;
312
widget_class->drag_motion = egg_list_box_real_drag_motion;
313
container_class->add = egg_list_box_real_add;
314
container_class->remove = egg_list_box_real_remove;
315
container_class->forall = egg_list_box_real_forall_internal;
316
container_class->child_type = egg_list_box_real_child_type;
317
klass->activate_cursor_child = egg_list_box_real_activate_cursor_child;
318
klass->toggle_cursor_child = egg_list_box_real_toggle_cursor_child;
319
klass->move_cursor = egg_list_box_real_move_cursor;
320
321
signals[CHILD_SELECTED] =
322
g_signal_new ("child-selected",
323
EGG_TYPE_LIST_BOX,
324
G_SIGNAL_RUN_LAST,
325
G_STRUCT_OFFSET (EggListBoxClass, child_selected),
326
NULL, NULL,
327
g_cclosure_marshal_VOID__OBJECT,
328
G_TYPE_NONE, 1,
329
GTK_TYPE_WIDGET);
330
signals[CHILD_ACTIVATED] =
331
g_signal_new ("child-activated",
332
EGG_TYPE_LIST_BOX,
333
G_SIGNAL_RUN_LAST,
334
G_STRUCT_OFFSET (EggListBoxClass, child_activated),
335
NULL, NULL,
336
g_cclosure_marshal_VOID__OBJECT,
337
G_TYPE_NONE, 1,
338
GTK_TYPE_WIDGET);
339
signals[ACTIVATE_CURSOR_CHILD] =
340
g_signal_new ("activate-cursor-child",
341
EGG_TYPE_LIST_BOX,
342
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
343
G_STRUCT_OFFSET (EggListBoxClass, activate_cursor_child),
344
NULL, NULL,
345
g_cclosure_marshal_VOID__VOID,
346
G_TYPE_NONE, 0);
347
signals[TOGGLE_CURSOR_CHILD] =
348
g_signal_new ("toggle-cursor-child",
349
EGG_TYPE_LIST_BOX,
350
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
351
G_STRUCT_OFFSET (EggListBoxClass, toggle_cursor_child),
352
NULL, NULL,
353
g_cclosure_marshal_VOID__VOID,
354
G_TYPE_NONE, 0);
355
signals[MOVE_CURSOR] =
356
g_signal_new ("move-cursor",
357
EGG_TYPE_LIST_BOX,
358
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
359
G_STRUCT_OFFSET (EggListBoxClass, move_cursor),
360
NULL, NULL,
361
_egg_marshal_VOID__ENUM_INT,
362
G_TYPE_NONE, 2,
363
GTK_TYPE_MOVEMENT_STEP, G_TYPE_INT);
364
365
widget_class->activate_signal = signals[ACTIVATE_CURSOR_CHILD];
366
367
binding_set = gtk_binding_set_by_class (klass);
368
egg_list_box_add_move_binding (binding_set, GDK_KEY_Home, 0,
369
GTK_MOVEMENT_BUFFER_ENDS, -1);
370
egg_list_box_add_move_binding (binding_set, GDK_KEY_KP_Home, 0,
371
GTK_MOVEMENT_BUFFER_ENDS, -1);
372
egg_list_box_add_move_binding (binding_set, GDK_KEY_End, 0,
373
GTK_MOVEMENT_BUFFER_ENDS, 1);
374
egg_list_box_add_move_binding (binding_set, GDK_KEY_KP_End, 0,
375
GTK_MOVEMENT_BUFFER_ENDS, 1);
376
egg_list_box_add_move_binding (binding_set, GDK_KEY_Up, GDK_CONTROL_MASK,
377
GTK_MOVEMENT_DISPLAY_LINES, -1);
378
egg_list_box_add_move_binding (binding_set, GDK_KEY_KP_Up, GDK_CONTROL_MASK,
379
GTK_MOVEMENT_DISPLAY_LINES, -1);
380
egg_list_box_add_move_binding (binding_set, GDK_KEY_Down, GDK_CONTROL_MASK,
381
GTK_MOVEMENT_DISPLAY_LINES, 1);
382
egg_list_box_add_move_binding (binding_set, GDK_KEY_KP_Down, GDK_CONTROL_MASK,
383
GTK_MOVEMENT_DISPLAY_LINES, 1);
384
egg_list_box_add_move_binding (binding_set, GDK_KEY_Page_Up, 0,
385
GTK_MOVEMENT_PAGES, -1);
386
egg_list_box_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0,
387
GTK_MOVEMENT_PAGES, -1);
388
egg_list_box_add_move_binding (binding_set, GDK_KEY_Page_Down, 0,
389
GTK_MOVEMENT_PAGES, 1);
390
egg_list_box_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0,
391
GTK_MOVEMENT_PAGES, 1);
392
gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK,
393
"toggle-cursor-child", 0, NULL);
394
}
395
396
GtkWidget *
397
egg_list_box_get_selected_child (EggListBox *list_box)
398
{
399
EggListBoxPrivate *priv = list_box->priv;
400
401
g_return_val_if_fail (list_box != NULL, NULL);
402
403
if (priv->selected_child != NULL)
404
return priv->selected_child->widget;
405
406
return NULL;
407
}
408
409
GtkWidget *
410
egg_list_box_get_child_at_y (EggListBox *list_box, gint y)
411
{
412
EggListBoxChildInfo *child;
413
414
g_return_val_if_fail (list_box != NULL, NULL);
415
416
child = egg_list_box_find_child_at_y (list_box, y);
417
if (child == NULL)
418
return NULL;
419
420
return child->widget;
421
}
422
423
424
void
425
egg_list_box_select_child (EggListBox *list_box, GtkWidget *child)
426
{
427
EggListBoxChildInfo *info = NULL;
428
429
g_return_if_fail (list_box != NULL);
430
431
if (child != NULL)
432
info = egg_list_box_lookup_info (list_box, child);
433
434
egg_list_box_update_selected (list_box, info);
435
}
436
437
void
438
egg_list_box_set_adjustment (EggListBox *list_box,
439
GtkAdjustment *adjustment)
440
{
441
EggListBoxPrivate *priv = list_box->priv;
442
443
g_return_if_fail (list_box != NULL);
444
445
g_object_ref (adjustment);
446
if (priv->adjustment)
447
g_object_unref (priv->adjustment);
448
priv->adjustment = adjustment;
449
gtk_container_set_focus_vadjustment (GTK_CONTAINER (list_box),
450
adjustment);
451
}
452
453
void
454
egg_list_box_add_to_scrolled (EggListBox *list_box,
455
GtkScrolledWindow *scrolled)
456
{
457
g_return_if_fail (list_box != NULL);
458
g_return_if_fail (scrolled != NULL);
459
460
gtk_scrolled_window_add_with_viewport (scrolled,
461
GTK_WIDGET (list_box));
462
egg_list_box_set_adjustment (list_box,
463
gtk_scrolled_window_get_vadjustment (scrolled));
464
}
465
466
467
void
468
egg_list_box_set_selection_mode (EggListBox *list_box, GtkSelectionMode mode)
469
{
470
EggListBoxPrivate *priv = list_box->priv;
471
472
g_return_if_fail (list_box != NULL);
473
474
if (mode == GTK_SELECTION_MULTIPLE)
475
{
476
g_warning ("egg-list-box.vala:115: Multiple selections not supported");
477
return;
478
}
479
480
priv->selection_mode = mode;
481
if (mode == GTK_SELECTION_NONE)
482
egg_list_box_update_selected (list_box, NULL);
483
}
484
485
486
void
487
egg_list_box_set_filter_func (EggListBox *list_box,
488
EggListBoxFilterFunc f,
489
void *f_target,
490
GDestroyNotify f_target_destroy_notify)
491
{
492
EggListBoxPrivate *priv = list_box->priv;
493
494
g_return_if_fail (list_box != NULL);
495
496
if (priv->filter_func_target_destroy_notify != NULL)
497
priv->filter_func_target_destroy_notify (priv->filter_func_target);
498
499
priv->filter_func = f;
500
priv->filter_func_target = f_target;
501
priv->filter_func_target_destroy_notify = f_target_destroy_notify;
502
503
egg_list_box_refilter (list_box);
504
}
505
506
void
507
egg_list_box_set_separator_funcs (EggListBox *list_box,
508
EggListBoxUpdateSeparatorFunc update_separator,
509
void *update_separator_target,
510
GDestroyNotify update_separator_target_destroy_notify)
511
{
512
EggListBoxPrivate *priv = list_box->priv;
513
514
g_return_if_fail (list_box != NULL);
515
516
if (priv->update_separator_func_target_destroy_notify != NULL)
517
priv->update_separator_func_target_destroy_notify (priv->update_separator_func_target);
518
519
priv->update_separator_func = update_separator;
520
priv->update_separator_func_target = update_separator_target;
521
priv->update_separator_func_target_destroy_notify = update_separator_target_destroy_notify;
522
egg_list_box_reseparate (list_box);
523
}
524
525
void
526
egg_list_box_refilter (EggListBox *list_box)
527
{
528
g_return_if_fail (list_box != NULL);
529
530
531
egg_list_box_apply_filter_all (list_box);
532
egg_list_box_reseparate (list_box);
533
gtk_widget_queue_resize (GTK_WIDGET (list_box));
534
}
535
536
static gint
537
do_sort (EggListBoxChildInfo *a,
538
EggListBoxChildInfo *b,
539
EggListBox *list_box)
540
{
541
EggListBoxPrivate *priv = list_box->priv;
542
543
return priv->sort_func (a->widget, b->widget,
544
priv->sort_func_target);
545
}
546
547
void
548
egg_list_box_resort (EggListBox *list_box)
549
{
550
EggListBoxPrivate *priv = list_box->priv;
551
552
g_return_if_fail (list_box != NULL);
553
554
g_sequence_sort (priv->children,
555
(GCompareDataFunc)do_sort, list_box);
556
egg_list_box_reseparate (list_box);
557
gtk_widget_queue_resize (GTK_WIDGET (list_box));
558
}
559
560
void
561
egg_list_box_reseparate (EggListBox *list_box)
562
{
563
EggListBoxPrivate *priv = list_box->priv;
564
GSequenceIter *iter;
565
566
g_return_if_fail (list_box != NULL);
567
568
for (iter = g_sequence_get_begin_iter (priv->children);
569
!g_sequence_iter_is_end (iter);
570
iter = g_sequence_iter_next (iter))
571
egg_list_box_update_separator (list_box, iter);
572
573
gtk_widget_queue_resize (GTK_WIDGET (list_box));
574
}
575
576
void
577
egg_list_box_set_sort_func (EggListBox *list_box,
578
GCompareDataFunc f,
579
void *f_target,
580
GDestroyNotify f_target_destroy_notify)
581
{
582
EggListBoxPrivate *priv = list_box->priv;
583
584
g_return_if_fail (list_box != NULL);
585
586
if (priv->sort_func_target_destroy_notify != NULL)
587
priv->sort_func_target_destroy_notify (priv->sort_func_target);
588
589
priv->sort_func = f;
590
priv->sort_func_target = f_target;
591
priv->sort_func_target_destroy_notify = f_target_destroy_notify;
592
egg_list_box_resort (list_box);
593
}
594
595
void
596
egg_list_box_child_changed (EggListBox *list_box, GtkWidget *widget)
597
{
598
EggListBoxPrivate *priv = list_box->priv;
599
EggListBoxChildInfo *info;
600
GSequenceIter *prev_next, *next;
601
602
g_return_if_fail (list_box != NULL);
603
g_return_if_fail (widget != NULL);
604
605
info = egg_list_box_lookup_info (list_box, widget);
606
if (info == NULL)
607
return;
608
609
prev_next = egg_list_box_get_next_visible (list_box, info->iter);
610
if (priv->sort_func != NULL)
611
{
612
g_sequence_sort_changed (info->iter,
613
(GCompareDataFunc)do_sort,
614
list_box);
615
gtk_widget_queue_resize (GTK_WIDGET (list_box));
616
}
617
egg_list_box_apply_filter (list_box, info->widget);
618
if (gtk_widget_get_visible (GTK_WIDGET (list_box)))
619
{
620
next = egg_list_box_get_next_visible (list_box, info->iter);
621
egg_list_box_update_separator (list_box, info->iter);
622
egg_list_box_update_separator (list_box, next);
623
egg_list_box_update_separator (list_box, prev_next);
624
}
625
}
626
627
void
628
egg_list_box_set_activate_on_single_click (EggListBox *list_box,
629
gboolean single)
630
{
631
EggListBoxPrivate *priv = list_box->priv;
632
633
g_return_if_fail (list_box != NULL);
634
635
priv->activate_single_click = single;
636
}
637
638
static void
639
egg_list_box_add_move_binding (GtkBindingSet *binding_set,
640
guint keyval,
641
GdkModifierType modmask,
642
GtkMovementStep step,
643
gint count)
644
{
645
gtk_binding_entry_add_signal (binding_set, keyval, modmask,
646
"move-cursor", (guint) 2, GTK_TYPE_MOVEMENT_STEP, step, G_TYPE_INT, count, NULL);
647
648
if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
649
return;
650
651
gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
652
"move-cursor", (guint) 2, GTK_TYPE_MOVEMENT_STEP, step, G_TYPE_INT, count, NULL);
653
}
654
655
static EggListBoxChildInfo*
656
egg_list_box_find_child_at_y (EggListBox *list_box, gint y)
657
{
658
EggListBoxPrivate *priv = list_box->priv;
659
EggListBoxChildInfo *child_info;
660
GSequenceIter *iter;
661
EggListBoxChildInfo *info;
662
663
child_info = NULL;
664
for (iter = g_sequence_get_begin_iter (priv->children);
665
!g_sequence_iter_is_end (iter);
666
iter = g_sequence_iter_next (iter))
667
{
668
info = (EggListBoxChildInfo*) g_sequence_get (iter);
669
if (y >= info->y && y < (info->y + info->height))
670
{
671
child_info = info;
672
break;
673
}
674
}
675
676
return child_info;
677
}
678
679
static void
680
egg_list_box_update_cursor (EggListBox *list_box,
681
EggListBoxChildInfo *child)
682
{
683
EggListBoxPrivate *priv = list_box->priv;
684
685
priv->cursor_child = child;
686
gtk_widget_grab_focus (GTK_WIDGET (list_box));
687
gtk_widget_queue_draw (GTK_WIDGET (list_box));
688
if (child != NULL && priv->adjustment != NULL)
689
{
690
GtkAllocation allocation;
691
gtk_widget_get_allocation (GTK_WIDGET (list_box), &allocation);
692
gtk_adjustment_clamp_page (priv->adjustment,
693
priv->cursor_child->y + allocation.y,
694
priv->cursor_child->y + allocation.y + priv->cursor_child->height);
695
}
696
}
697
698
static void
699
egg_list_box_update_selected (EggListBox *list_box,
700
EggListBoxChildInfo *child)
701
{
702
EggListBoxPrivate *priv = list_box->priv;
703
704
if (child != priv->selected_child &&
705
(child == NULL || priv->selection_mode != GTK_SELECTION_NONE))
706
{
707
priv->selected_child = child;
708
g_signal_emit (list_box, signals[CHILD_SELECTED], 0,
709
(priv->selected_child != NULL) ? priv->selected_child->widget : NULL);
710
gtk_widget_queue_draw (GTK_WIDGET (list_box));
711
}
712
if (child != NULL)
713
egg_list_box_update_cursor (list_box, child);
714
}
715
716
static void
717
egg_list_box_select_and_activate (EggListBox *list_box, EggListBoxChildInfo *child)
718
{
719
GtkWidget *w = NULL;
720
721
if (child != NULL)
722
w = child->widget;
723
724
egg_list_box_update_selected (list_box, child);
725
726
if (w != NULL)
727
g_signal_emit (list_box, signals[CHILD_ACTIVATED], 0, w);
728
}
729
730
static void
731
egg_list_box_update_prelight (EggListBox *list_box, EggListBoxChildInfo *child)
732
{
733
EggListBoxPrivate *priv = list_box->priv;
734
735
if (child != priv->prelight_child)
736
{
737
priv->prelight_child = child;
738
gtk_widget_queue_draw (GTK_WIDGET (list_box));
739
}
740
}
741
742
static void
743
egg_list_box_update_active (EggListBox *list_box, EggListBoxChildInfo *child)
744
{
745
EggListBoxPrivate *priv = list_box->priv;
746
gboolean val;
747
748
val = priv->active_child == child;
749
if (priv->active_child != NULL &&
750
val != priv->active_child_active)
751
{
752
priv->active_child_active = val;
753
gtk_widget_queue_draw (GTK_WIDGET (list_box));
754
}
755
}
756
757
static gboolean
758
egg_list_box_real_enter_notify_event (GtkWidget *widget,
759
GdkEventCrossing *event)
760
{
761
EggListBox *list_box = EGG_LIST_BOX (widget);
762
EggListBoxChildInfo *child;
763
764
765
if (event->window != gtk_widget_get_window (GTK_WIDGET (list_box)))
766
return FALSE;
767
768
child = egg_list_box_find_child_at_y (list_box, event->y);
769
egg_list_box_update_prelight (list_box, child);
770
egg_list_box_update_active (list_box, child);
771
772
return FALSE;
773
}
774
775
static gboolean
776
egg_list_box_real_leave_notify_event (GtkWidget *widget,
777
GdkEventCrossing *event)
778
{
779
EggListBox *list_box = EGG_LIST_BOX (widget);
780
EggListBoxChildInfo *child = NULL;
781
782
if (event->window != gtk_widget_get_window (GTK_WIDGET (list_box)))
783
return FALSE;
784
785
if (event->detail != GDK_NOTIFY_INFERIOR)
786
child = NULL;
787
else
788
child = egg_list_box_find_child_at_y (list_box, event->y);
789
790
egg_list_box_update_prelight (list_box, child);
791
egg_list_box_update_active (list_box, child);
792
793
return FALSE;
794
}
795
796
static gboolean
797
egg_list_box_real_motion_notify_event (GtkWidget *widget,
798
GdkEventMotion *event)
799
{
800
EggListBox *list_box = EGG_LIST_BOX (widget);
801
EggListBoxChildInfo *child;
802
803
804
child = egg_list_box_find_child_at_y (list_box, event->y);
805
egg_list_box_update_prelight (list_box, child);
806
egg_list_box_update_active (list_box, child);
807
808
return FALSE;
809
}
810
811
static gboolean
812
egg_list_box_real_button_press_event (GtkWidget *widget,
813
GdkEventButton *event)
814
{
815
EggListBox *list_box = EGG_LIST_BOX (widget);
816
EggListBoxPrivate *priv = list_box->priv;
817
818
if (event->button == 1)
819
{
820
EggListBoxChildInfo *child;
821
child = egg_list_box_find_child_at_y (list_box, event->y);
822
if (child != NULL)
823
{
824
priv->active_child = child;
825
priv->active_child_active = TRUE;
826
gtk_widget_queue_draw (GTK_WIDGET (list_box));
827
if (event->type == GDK_2BUTTON_PRESS &&
828
!priv->activate_single_click &&
829
child->widget != NULL)
830
g_signal_emit (list_box, signals[CHILD_ACTIVATED], 0,
831
child->widget);
832
833
}
834
/* TODO:
835
Should mark as active while down,
836
and handle grab breaks */
837
}
838
839
return FALSE;
840
}
841
842
static gboolean
843
egg_list_box_real_button_release_event (GtkWidget *widget,
844
GdkEventButton *event)
845
{
846
EggListBox *list_box = EGG_LIST_BOX (widget);
847
EggListBoxPrivate *priv = list_box->priv;
848
849
if (event->button == 1)
850
{
851
if (priv->active_child != NULL &&
852
priv->active_child_active)
853
{
854
if (priv->activate_single_click)
855
egg_list_box_select_and_activate (list_box, priv->active_child);
856
else
857
egg_list_box_update_selected (list_box, priv->active_child);
858
}
859
priv->active_child = NULL;
860
priv->active_child_active = FALSE;
861
gtk_widget_queue_draw (GTK_WIDGET (list_box));
862
}
863
864
return FALSE;
865
}
866
867
static void
868
egg_list_box_real_show (GtkWidget *widget)
869
{
870
EggListBox * list_box = EGG_LIST_BOX (widget);
871
872
egg_list_box_reseparate (list_box);
873
874
GTK_WIDGET_CLASS (egg_list_box_parent_class)->show ((GtkWidget*) G_TYPE_CHECK_INSTANCE_CAST (list_box, GTK_TYPE_CONTAINER, GtkContainer));
875
}
876
877
878
static gboolean
879
egg_list_box_real_focus (GtkWidget* widget, GtkDirectionType direction)
880
{
881
EggListBox *list_box = EGG_LIST_BOX (widget);
882
EggListBoxPrivate *priv = list_box->priv;
883
gboolean had_focus = FALSE;
884
gboolean focus_into = FALSE;
885
GtkWidget* recurse_into;
886
EggListBoxChildInfo *current_focus_child;
887
EggListBoxChildInfo *next_focus_child;
888
gboolean modify_selection_pressed;
889
GdkModifierType state = 0;
890
891
recurse_into = NULL;
892
focus_into = TRUE;
893
894
g_object_get (GTK_WIDGET (list_box), "has-focus", &had_focus, NULL);
895
current_focus_child = NULL;
896
next_focus_child = NULL;
897
if (had_focus)
898
{
899
/* If on row, going right, enter into possible container */
900
if (direction == GTK_DIR_RIGHT || direction == GTK_DIR_TAB_FORWARD)
901
{
902
if (priv->cursor_child != NULL)
903
recurse_into = priv->cursor_child->widget;
904
}
905
current_focus_child = priv->cursor_child;
906
/* Unless we're going up/down we're always leaving
907
the container */
908
if (direction != GTK_DIR_UP && direction != GTK_DIR_DOWN)
909
focus_into = FALSE;
910
}
911
else if (gtk_container_get_focus_child ((GtkContainer*) list_box) != NULL)
912
{
913
/* There is a focus child, always navigat inside it first */
914
recurse_into = gtk_container_get_focus_child ((GtkContainer*) list_box);
915
current_focus_child = egg_list_box_lookup_info (list_box, recurse_into);
916
917
/* If exiting child container to the right, exit row */
918
if (direction == GTK_DIR_RIGHT || direction == GTK_DIR_TAB_FORWARD)
919
focus_into = FALSE;
920
921
/* If exiting child container to the left, select row or out */
922
if (direction == GTK_DIR_LEFT || direction == GTK_DIR_TAB_BACKWARD)
923
next_focus_child = current_focus_child;
924
}
925
else
926
{
927
/* If coming from the left, enter into possible container */
928
if (direction == GTK_DIR_LEFT || direction == GTK_DIR_TAB_BACKWARD)
929
{
930
if (priv->selected_child != NULL)
931
recurse_into = priv->selected_child->widget;
932
}
933
}
934
935
if (recurse_into != NULL)
936
{
937
if (gtk_widget_child_focus (recurse_into, direction))
938
return TRUE;
939
}
940
941
if (!focus_into)
942
return FALSE; /* Focus is leaving us */
943
944
/* TODO: This doesn't handle up/down going into a focusable separator */
945
946
if (next_focus_child == NULL)
947
{
948
if (current_focus_child != NULL)
949
{
950
GSequenceIter* i;
951
if (direction == GTK_DIR_UP)
952
{
953
i = egg_list_box_get_previous_visible (list_box, current_focus_child->iter);
954
if (i != NULL)
955
next_focus_child = g_sequence_get (i);
956
957
}
958
else
959
{
960
i = egg_list_box_get_next_visible (list_box, current_focus_child->iter);
961
if (!g_sequence_iter_is_end (i))
962
next_focus_child = g_sequence_get (i);
963
964
}
965
}
966
else
967
{
968
switch (direction)
969
{
970
case GTK_DIR_DOWN:
971
case GTK_DIR_TAB_FORWARD:
972
next_focus_child = egg_list_box_get_first_visible (list_box);
973
break;
974
case GTK_DIR_UP:
975
case GTK_DIR_TAB_BACKWARD:
976
next_focus_child = egg_list_box_get_last_visible (list_box);
977
break;
978
default:
979
next_focus_child = priv->selected_child;
980
if (next_focus_child == NULL)
981
next_focus_child =
982
egg_list_box_get_first_visible (list_box);
983
break;
984
}
985
}
986
}
987
988
if (next_focus_child == NULL)
989
{
990
if (direction == GTK_DIR_UP || direction == GTK_DIR_DOWN)
991
{
992
gtk_widget_error_bell (GTK_WIDGET (list_box));
993
return TRUE;
994
}
995
996
return FALSE;
997
}
998
999
modify_selection_pressed = FALSE;
1000
if (gtk_get_current_event_state (&state))
1001
{
1002
GdkModifierType modify_mod_mask;
1003
modify_mod_mask =
1004
gtk_widget_get_modifier_mask (GTK_WIDGET (list_box),
1005
GDK_MODIFIER_INTENT_MODIFY_SELECTION);
1006
if ((state & modify_mod_mask) == modify_mod_mask)
1007
modify_selection_pressed = TRUE;
1008
}
1009
1010
egg_list_box_update_cursor (list_box, next_focus_child);
1011
if (!modify_selection_pressed)
1012
egg_list_box_update_selected (list_box, next_focus_child);
1013
1014
return TRUE;
1015
}
1016
1017
typedef struct {
1018
EggListBoxChildInfo *child;
1019
GtkStateFlags state;
1020
} ChildFlags;
1021
1022
static ChildFlags*
1023
child_flags_find_or_add (ChildFlags *array,
1024
int *array_length,
1025
EggListBoxChildInfo *to_find)
1026
{
1027
gint i;
1028
1029
for (i = 0; i < *array_length; i++)
1030
{
1031
if (array[i].child == to_find)
1032
return &array[i];
1033
}
1034
1035
*array_length = *array_length + 1;
1036
array[*array_length - 1].child = to_find;
1037
array[*array_length - 1].state = 0;
1038
return &array[*array_length - 1];
1039
}
1040
1041
static gboolean
1042
egg_list_box_real_draw (GtkWidget* widget, cairo_t* cr)
1043
{
1044
EggListBox * list_box = EGG_LIST_BOX (widget);
1045
EggListBoxPrivate *priv = list_box->priv;
1046
GtkAllocation allocation = {0};
1047
GtkStyleContext* context;
1048
GtkStateFlags state;
1049
ChildFlags flags[3], *found;
1050
gint flags_length;
1051
int i;
1052
1053
gtk_widget_get_allocation (GTK_WIDGET (list_box), &allocation);
1054
context = gtk_widget_get_style_context (GTK_WIDGET (list_box));
1055
state = gtk_widget_get_state_flags (widget);
1056
gtk_render_background (context, cr, (gdouble) 0, (gdouble) 0, (gdouble) allocation.width, (gdouble) allocation.height);
1057
flags_length = 0;
1058
1059
if (priv->selected_child != NULL)
1060
{
1061
found = child_flags_find_or_add (flags, &flags_length, priv->selected_child);
1062
found->state |= (state | GTK_STATE_FLAG_SELECTED);
1063
}
1064
1065
if (priv->prelight_child != NULL)
1066
{
1067
found = child_flags_find_or_add (flags, &flags_length, priv->prelight_child);
1068
found->state |= (state | GTK_STATE_FLAG_PRELIGHT);
1069
}
1070
1071
if (priv->active_child != NULL && priv->active_child_active)
1072
{
1073
found = child_flags_find_or_add (flags, &flags_length, priv->active_child);
1074
found->state |= (state | GTK_STATE_FLAG_ACTIVE);
1075
}
1076
1077
for (i = 0; i < flags_length; i++)
1078
{
1079
ChildFlags *flag = &flags[i];
1080
gtk_style_context_save (context);
1081
gtk_style_context_set_state (context, flag->state);
1082
gtk_render_background (context, cr, 0, flag->child->y, allocation.width, flag->child->height);
1083
gtk_style_context_restore (context);
1084
}
1085
1086
if (gtk_widget_has_visible_focus (GTK_WIDGET (list_box)) && priv->cursor_child != NULL)
1087
gtk_render_focus (context, cr, 0, priv->cursor_child->y, allocation.width, priv->cursor_child->height);
1088
1089
GTK_WIDGET_CLASS (egg_list_box_parent_class)->draw ((GtkWidget*) G_TYPE_CHECK_INSTANCE_CAST (list_box, GTK_TYPE_CONTAINER, GtkContainer), cr);
1090
1091
return TRUE;
1092
}
1093
1094
1095
static void
1096
egg_list_box_real_realize (GtkWidget* widget)
1097
{
1098
EggListBox *list_box = EGG_LIST_BOX (widget);
1099
GtkAllocation allocation;
1100
GdkWindowAttr attributes = {0};
1101
GdkWindow *window;
1102
1103
gtk_widget_get_allocation (GTK_WIDGET (list_box), &allocation);
1104
gtk_widget_set_realized (GTK_WIDGET (list_box), TRUE);
1105
1106
attributes.x = allocation.x;
1107
attributes.y = allocation.y;
1108
attributes.width = allocation.width;
1109
attributes.height = allocation.height;
1110
attributes.window_type = GDK_WINDOW_CHILD;
1111
attributes.event_mask = gtk_widget_get_events (GTK_WIDGET (list_box)) |
1112
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK |
1113
GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK;
1114
attributes.wclass = GDK_INPUT_OUTPUT;
1115
1116
window = gdk_window_new (gtk_widget_get_parent_window (GTK_WIDGET (list_box)),
1117
&attributes, GDK_WA_X | GDK_WA_Y);
1118
gtk_style_context_set_background (gtk_widget_get_style_context (GTK_WIDGET (list_box)), window);
1119
gdk_window_set_user_data (window, (GObject*) list_box);
1120
gtk_widget_set_window (GTK_WIDGET (list_box), window); /* Passes ownership */
1121
}
1122
1123
1124
static void
1125
egg_list_box_apply_filter (EggListBox *list_box, GtkWidget *child)
1126
{
1127
EggListBoxPrivate *priv = list_box->priv;
1128
gboolean do_show;
1129
1130
do_show = TRUE;
1131
if (priv->filter_func != NULL)
1132
do_show = priv->filter_func (child, priv->filter_func_target);
1133
1134
gtk_widget_set_child_visible (child, do_show);
1135
}
1136
1137
static void
1138
egg_list_box_apply_filter_all (EggListBox *list_box)
1139
{
1140
EggListBoxPrivate *priv = list_box->priv;
1141
EggListBoxChildInfo *child_info;
1142
GSequenceIter *iter;
1143
1144
for (iter = g_sequence_get_begin_iter (priv->children);
1145
!g_sequence_iter_is_end (iter);
1146
iter = g_sequence_iter_next (iter))
1147
{
1148
child_info = g_sequence_get (iter);
1149
egg_list_box_apply_filter (list_box, child_info->widget);
1150
}
1151
}
1152
1153
/* Children are visible if they are shown by the app (visible)
1154
and not filtered out (child_visible) by the listbox */
1155
static gboolean
1156
child_is_visible (GtkWidget *child)
1157
{
1158
return gtk_widget_get_visible (child) && gtk_widget_get_child_visible (child);
1159
}
1160
1161
static EggListBoxChildInfo*
1162
egg_list_box_get_first_visible (EggListBox *list_box)
1163
{
1164
EggListBoxPrivate *priv = list_box->priv;
1165
EggListBoxChildInfo *child_info;
1166
GSequenceIter *iter;
1167
1168
for (iter = g_sequence_get_begin_iter (priv->children);
1169
!g_sequence_iter_is_end (iter);
1170
iter = g_sequence_iter_next (iter))
1171
{
1172
child_info = g_sequence_get (iter);
1173
if (child_is_visible (child_info->widget))
1174
return child_info;
1175
}
1176
1177
return NULL;
1178
}
1179
1180
1181
static EggListBoxChildInfo*
1182
egg_list_box_get_last_visible (EggListBox *list_box)
1183
{
1184
EggListBoxPrivate *priv = list_box->priv;
1185
EggListBoxChildInfo *child_info;
1186
GSequenceIter *iter;
1187
1188
iter = g_sequence_get_end_iter (priv->children);
1189
while (!g_sequence_iter_is_begin (iter))
1190
{
1191
iter = g_sequence_iter_prev (iter);
1192
child_info = g_sequence_get (iter);
1193
if (child_is_visible (child_info->widget))
1194
return child_info;
1195
}
1196
1197
return NULL;
1198
}
1199
1200
static GSequenceIter*
1201
egg_list_box_get_previous_visible (EggListBox *list_box,
1202
GSequenceIter* iter)
1203
{
1204
EggListBoxChildInfo *child_info;
1205
1206
if (g_sequence_iter_is_begin (iter))
1207
return NULL;
1208
1209
do
1210
{
1211
iter = g_sequence_iter_prev (iter);
1212
child_info = g_sequence_get (iter);
1213
if (child_is_visible (child_info->widget))
1214
return iter;
1215
}
1216
while (!g_sequence_iter_is_begin (iter));
1217
1218
return NULL;
1219
}
1220
1221
static GSequenceIter*
1222
egg_list_box_get_next_visible (EggListBox *list_box, GSequenceIter* iter)
1223
{
1224
EggListBoxChildInfo *child_info;
1225
1226
if (g_sequence_iter_is_end (iter))
1227
return iter;
1228
1229
do
1230
{
1231
iter = g_sequence_iter_next (iter);
1232
if (!g_sequence_iter_is_end (iter))
1233
{
1234
child_info = g_sequence_get (iter);
1235
if (child_is_visible (child_info->widget))
1236
return iter;
1237
}
1238
}
1239
while (!g_sequence_iter_is_end (iter));
1240
1241
return iter;
1242
}
1243
1244
1245
static void
1246
egg_list_box_update_separator (EggListBox *list_box, GSequenceIter* iter)
1247
{
1248
EggListBoxPrivate *priv = list_box->priv;
1249
EggListBoxChildInfo *info;
1250
GSequenceIter *before_iter;
1251
GtkWidget *child;
1252
GtkWidget *before_child;
1253
EggListBoxChildInfo *before_info;
1254
GtkWidget *old_separator;
1255
1256
if (iter == NULL || g_sequence_iter_is_end (iter))
1257
return;
1258
1259
info = g_sequence_get (iter);
1260
before_iter = egg_list_box_get_previous_visible (list_box, iter);
1261
child = info->widget;
1262
if (child)
1263
g_object_ref (child);
1264
before_child = NULL;
1265
if (before_iter != NULL)
1266
{
1267
before_info = g_sequence_get (before_iter);
1268
before_child = before_info->widget;
1269
if (before_child)
1270
g_object_ref (before_child);
1271
}
1272
1273
if (priv->update_separator_func != NULL &&
1274
child_is_visible (child))
1275
{
1276
old_separator = info->separator;
1277
if (old_separator)
1278
g_object_ref (old_separator);
1279
priv->update_separator_func (&info->separator,
1280
child,
1281
before_child,
1282
priv->update_separator_func_target);
1283
if (old_separator != info->separator)
1284
{
1285
if (old_separator != NULL)
1286
{
1287
gtk_widget_unparent (old_separator);
1288
g_hash_table_remove (priv->separator_hash, old_separator);
1289
}
1290
if (info->separator != NULL)
1291
{
1292
g_hash_table_insert (priv->separator_hash, info->separator, info);
1293
gtk_widget_set_parent (info->separator, GTK_WIDGET (list_box));
1294
gtk_widget_show (info->separator);
1295
}
1296
gtk_widget_queue_resize (GTK_WIDGET (list_box));
1297
}
1298
if (old_separator)
1299
g_object_unref (old_separator);
1300
}
1301
else
1302
{
1303
if (info->separator != NULL)
1304
{
1305
g_hash_table_remove (priv->separator_hash, info->separator);
1306
gtk_widget_unparent (info->separator);
1307
g_clear_object (&info->separator);
1308
gtk_widget_queue_resize (GTK_WIDGET (list_box));
1309
}
1310
}
1311
if (before_child)
1312
g_object_unref (before_child);
1313
if (child)
1314
g_object_unref (child);
1315
}
1316
1317
static EggListBoxChildInfo*
1318
egg_list_box_lookup_info (EggListBox *list_box, GtkWidget* child)
1319
{
1320
EggListBoxPrivate *priv = list_box->priv;
1321
1322
return g_hash_table_lookup (priv->child_hash, child);
1323
}
1324
1325
static void
1326
child_visibility_changed (GObject* object, GParamSpec* pspec, EggListBox *list_box)
1327
{
1328
EggListBoxChildInfo *info;
1329
1330
if (gtk_widget_get_visible (GTK_WIDGET (list_box)))
1331
{
1332
info = egg_list_box_lookup_info (list_box, GTK_WIDGET (object));
1333
if (info != NULL)
1334
{
1335
egg_list_box_update_separator (list_box, info->iter);
1336
egg_list_box_update_separator (list_box,
1337
egg_list_box_get_next_visible (list_box, info->iter));
1338
}
1339
}
1340
}
1341
1342
static void
1343
egg_list_box_real_add (GtkContainer* container, GtkWidget* child)
1344
{
1345
EggListBox *list_box = EGG_LIST_BOX (container);
1346
EggListBoxPrivate *priv = list_box->priv;
1347
EggListBoxChildInfo *info;
1348
GSequenceIter* iter = NULL;
1349
info = egg_list_box_child_info_new (child);
1350
g_hash_table_insert (priv->child_hash, child, info);
1351
if (priv->sort_func != NULL)
1352
iter = g_sequence_insert_sorted (priv->children, info,
1353
(GCompareDataFunc)do_sort, list_box);
1354
else
1355
iter = g_sequence_append (priv->children, info);
1356
1357
info->iter = iter;
1358
gtk_widget_set_parent (child, GTK_WIDGET (list_box));
1359
egg_list_box_apply_filter (list_box, child);
1360
if (gtk_widget_get_visible (GTK_WIDGET (list_box)))
1361
{
1362
egg_list_box_update_separator (list_box, iter);
1363
egg_list_box_update_separator (list_box, egg_list_box_get_next_visible (list_box, iter));
1364
}
1365
g_signal_connect_object (child, "notify::visible",
1366
(GCallback) child_visibility_changed, list_box, 0);
1367
}
1368
1369
static void
1370
egg_list_box_real_remove (GtkContainer* container, GtkWidget* child)
1371
{
1372
EggListBox *list_box = EGG_LIST_BOX (container);
1373
EggListBoxPrivate *priv = list_box->priv;
1374
gboolean was_visible;
1375
EggListBoxChildInfo *info;
1376
GSequenceIter *next;
1377
1378
g_return_if_fail (child != NULL);
1379
was_visible = gtk_widget_get_visible (child);
1380
1381
g_signal_handlers_disconnect_by_func (child, (GCallback) child_visibility_changed, list_box);
1382
1383
info = egg_list_box_lookup_info (list_box, child);
1384
if (info == NULL)
1385
{
1386
info = g_hash_table_lookup (priv->separator_hash, child);
1387
if (info != NULL)
1388
{
1389
g_hash_table_remove (priv->separator_hash, child);
1390
g_clear_object (&info->separator);
1391
gtk_widget_unparent (child);
1392
if (was_visible && gtk_widget_get_visible (GTK_WIDGET (list_box)))
1393
gtk_widget_queue_resize (GTK_WIDGET (list_box));
1394
}
1395
else
1396
{
1397
g_warning ("egg-list-box.vala:846: Tried to remove non-child %p\n", child);
1398
}
1399
return;
1400
}
1401
1402
if (info->separator != NULL)
1403
{
1404
g_hash_table_remove (priv->separator_hash, info->separator);
1405
gtk_widget_unparent (info->separator);
1406
g_clear_object (&info->separator);
1407
}
1408
1409
if (info == priv->selected_child)
1410
egg_list_box_update_selected (list_box, NULL);
1411
if (info == priv->prelight_child)
1412
priv->prelight_child = NULL;
1413
if (info == priv->cursor_child)
1414
priv->cursor_child = NULL;
1415
if (info == priv->active_child)
1416
priv->active_child = NULL;
1417
1418
next = egg_list_box_get_next_visible (list_box, info->iter);
1419
gtk_widget_unparent (child);
1420
g_hash_table_remove (priv->child_hash, child);
1421
g_sequence_remove (info->iter);
1422
if (gtk_widget_get_visible (GTK_WIDGET (list_box)))
1423
egg_list_box_update_separator (list_box, next);
1424
1425
if (was_visible && gtk_widget_get_visible (GTK_WIDGET (list_box)))
1426
gtk_widget_queue_resize (GTK_WIDGET (list_box));
1427
}
1428
1429
1430
static void
1431
egg_list_box_real_forall_internal (GtkContainer* container,
1432
gboolean include_internals,
1433
GtkCallback callback,
1434
void* callback_target)
1435
{
1436
EggListBox *list_box = EGG_LIST_BOX (container);
1437
EggListBoxPrivate *priv = list_box->priv;
1438
GSequenceIter *iter;
1439
EggListBoxChildInfo *child_info;
1440
1441
iter = g_sequence_get_begin_iter (priv->children);
1442
while (!g_sequence_iter_is_end (iter))
1443
{
1444
child_info = g_sequence_get (iter);
1445
iter = g_sequence_iter_next (iter);
1446
if (child_info->separator != NULL && include_internals)
1447
callback (child_info->separator, callback_target);
1448
callback (child_info->widget, callback_target);
1449
}
1450
}
1451
1452
static void
1453
egg_list_box_real_compute_expand_internal (GtkWidget* widget,
1454
gboolean* hexpand,
1455
gboolean* vexpand)
1456
{
1457
GTK_WIDGET_CLASS (egg_list_box_parent_class)->compute_expand (widget,
1458
hexpand, vexpand);
1459
1460
/* We don't expand vertically beyound the minimum size */
1461
if (vexpand)
1462
*vexpand = FALSE;
1463
}
1464
1465
static GType
1466
egg_list_box_real_child_type (GtkContainer* container)
1467
{
1468
return GTK_TYPE_WIDGET;
1469
}
1470
1471
static GtkSizeRequestMode
1472
egg_list_box_real_get_request_mode (GtkWidget* widget)
1473
{
1474
return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
1475
}
1476
1477
static void
1478
egg_list_box_real_get_preferred_height (GtkWidget* widget,
1479
gint* minimum_height,
1480
gint* natural_height)
1481
{
1482
gint natural_width;
1483
egg_list_box_real_get_preferred_width (widget, NULL, &natural_width);
1484
egg_list_box_real_get_preferred_height_for_width (widget, natural_width,
1485
minimum_height, natural_height);
1486
}
1487
1488
static void
1489
egg_list_box_real_get_preferred_height_for_width (GtkWidget* widget, gint width,
1490
gint* minimum_height_out, gint* natural_height_out)
1491
{
1492
EggListBox *list_box = EGG_LIST_BOX (widget);
1493
EggListBoxPrivate *priv = list_box->priv;
1494
GSequenceIter *iter;
1495
gint minimum_height;
1496
gint natural_height;
1497
GtkStyleContext *context;
1498
gint focus_width;
1499
gint focus_pad;
1500
1501
minimum_height = 0;
1502
1503
context = gtk_widget_get_style_context (GTK_WIDGET (list_box));
1504
gtk_style_context_get_style (context,
1505
"focus-line-width", &focus_width,
1506
"focus-padding", &focus_pad, NULL);
1507
1508
for (iter = g_sequence_get_begin_iter (priv->children);
1509
!g_sequence_iter_is_end (iter);
1510
iter = g_sequence_iter_next (iter))
1511
{
1512
EggListBoxChildInfo *child_info;
1513
GtkWidget *child;
1514
gint child_min = 0;
1515
child_info = g_sequence_get (iter);
1516
child = child_info->widget;
1517
1518
if (!child_is_visible (child))
1519
continue;
1520
1521
if (child_info->separator != NULL)
1522
{
1523
gtk_widget_get_preferred_height_for_width (child_info->separator, width, &child_min, NULL);
1524
minimum_height += child_min;
1525
}
1526
gtk_widget_get_preferred_height_for_width (child, width - 2 * (focus_width + focus_pad),
1527
&child_min, NULL);
1528
minimum_height += child_min + 2 * (focus_width + focus_pad);
1529
}
1530
1531
/* We always allocate the minimum height, since handling
1532
expanding rows is way too costly, and unlikely to
1533
be used, as lists are generally put inside a scrolling window
1534
anyway.
1535
*/
1536
natural_height = minimum_height;
1537
if (minimum_height_out)
1538
*minimum_height_out = minimum_height;
1539
if (natural_height_out)
1540
*natural_height_out = natural_height;
1541
}
1542
1543
static void
1544
egg_list_box_real_get_preferred_width (GtkWidget* widget, gint* minimum_width_out, gint* natural_width_out)
1545
{
1546
EggListBox *list_box = EGG_LIST_BOX (widget);
1547
EggListBoxPrivate *priv = list_box->priv;
1548
gint minimum_width;
1549
gint natural_width;
1550
GtkStyleContext *context;
1551
gint focus_width;
1552
gint focus_pad;
1553
GSequenceIter *iter;
1554
EggListBoxChildInfo *child_info;
1555
GtkWidget *child;
1556
gint child_min;
1557
gint child_nat;
1558
1559
context = gtk_widget_get_style_context (GTK_WIDGET (list_box));
1560
gtk_style_context_get_style (context, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL);
1561
1562
minimum_width = 0;
1563
natural_width = 0;
1564
1565
for (iter = g_sequence_get_begin_iter (priv->children);
1566
!g_sequence_iter_is_end (iter);
1567
iter = g_sequence_iter_next (iter))
1568
{
1569
child_info = g_sequence_get (iter);
1570
child = child_info->widget;
1571
if (!child_is_visible (child))
1572
continue;
1573
1574
gtk_widget_get_preferred_width (child, &child_min, &child_nat);
1575
minimum_width = MAX (minimum_width, child_min + 2 * (focus_width + focus_pad));
1576
natural_width = MAX (natural_width, child_nat + 2 * (focus_width + focus_pad));
1577
1578
if (child_info->separator != NULL)
1579
{
1580
gtk_widget_get_preferred_width (child_info->separator, &child_min, &child_nat);
1581
minimum_width = MAX (minimum_width, child_min);
1582
natural_width = MAX (natural_width, child_nat);
1583
}
1584
}
1585
1586
if (minimum_width_out)
1587
*minimum_width_out = minimum_width;
1588
if (natural_width_out)
1589
*natural_width_out = natural_width;
1590
}
1591
1592
static void
1593
egg_list_box_real_get_preferred_width_for_height (GtkWidget *widget, gint height,
1594
gint *minimum_width, gint *natural_width)
1595
{
1596
EggListBox *list_box = EGG_LIST_BOX (widget);
1597
egg_list_box_real_get_preferred_width (GTK_WIDGET (list_box), minimum_width, natural_width);
1598
}
1599
1600
static void
1601
egg_list_box_real_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
1602
{
1603
EggListBox *list_box = EGG_LIST_BOX (widget);
1604
EggListBoxPrivate *priv = list_box->priv;
1605
GtkAllocation child_allocation;
1606
GtkAllocation separator_allocation;
1607
EggListBoxChildInfo *child_info;
1608
GdkWindow *window;
1609
GtkWidget *child;
1610
GSequenceIter *iter;
1611
GtkStyleContext *context;
1612
gint focus_width;
1613
gint focus_pad;
1614
int child_min;
1615
1616
1617
child_allocation.x = 0;
1618
child_allocation.y = 0;
1619
child_allocation.width = 0;
1620
child_allocation.height = 0;
1621
1622
separator_allocation.x = 0;
1623
separator_allocation.y = 0;
1624
separator_allocation.width = 0;
1625
separator_allocation.height = 0;
1626
1627
gtk_widget_set_allocation (GTK_WIDGET (list_box), allocation);
1628
window = gtk_widget_get_window (GTK_WIDGET (list_box));
1629
if (window != NULL)
1630
gdk_window_move_resize (window,
1631
allocation->x, allocation->y,
1632
allocation->width, allocation->height);
1633
1634
context = gtk_widget_get_style_context (GTK_WIDGET (list_box));
1635
gtk_style_context_get_style (context,
1636
"focus-line-width", &focus_width,
1637
"focus-padding", &focus_pad,
1638
NULL);
1639
child_allocation.x = 0 + focus_width + focus_pad;
1640
child_allocation.y = 0;
1641
child_allocation.width = allocation->width - 2 * (focus_width + focus_pad);
1642
separator_allocation.x = 0;
1643
separator_allocation.width = allocation->width;
1644
1645
for (iter = g_sequence_get_begin_iter (priv->children);
1646
!g_sequence_iter_is_end (iter);
1647
iter = g_sequence_iter_next (iter))
1648
{
1649
child_info = g_sequence_get (iter);
1650
child = child_info->widget;
1651
if (!child_is_visible (child))
1652
{
1653
child_info->y = child_allocation.y;
1654
child_info->height = 0;
1655
continue;
1656
}
1657
1658
if (child_info->separator != NULL)
1659
{
1660
gtk_widget_get_preferred_height_for_width (child_info->separator,
1661
allocation->width, &child_min, NULL);
1662
separator_allocation.height = child_min;
1663
separator_allocation.y = child_allocation.y;
1664
gtk_widget_size_allocate (child_info->separator,
1665
&separator_allocation);
1666
child_allocation.y += child_min;
1667
}
1668
1669
child_info->y = child_allocation.y;
1670
child_allocation.y += focus_width + focus_pad;
1671
1672
gtk_widget_get_preferred_height_for_width (child, child_allocation.width, &child_min, NULL);
1673
child_allocation.height = child_min;
1674
1675
child_info->height = child_allocation.height + 2 * (focus_width + focus_pad);
1676
gtk_widget_size_allocate (child, &child_allocation);
1677
1678
child_allocation.y += child_min + focus_width + focus_pad;
1679
}
1680
}
1681
1682
void
1683
egg_list_box_drag_unhighlight_widget (EggListBox *list_box)
1684
{
1685
EggListBoxPrivate *priv = list_box->priv;
1686
1687
g_return_if_fail (list_box != NULL);
1688
1689
if (priv->drag_highlighted_widget == NULL)
1690
return;
1691
1692
gtk_drag_unhighlight (priv->drag_highlighted_widget);
1693
g_clear_object (&priv->drag_highlighted_widget);
1694
}
1695
1696
1697
void
1698
egg_list_box_drag_highlight_widget (EggListBox *list_box, GtkWidget *child)
1699
{
1700
EggListBoxPrivate *priv = list_box->priv;
1701
GtkWidget *old_highlight;
1702
1703
g_return_if_fail (list_box != NULL);
1704
g_return_if_fail (child != NULL);
1705
1706
if (priv->drag_highlighted_widget == child)
1707
return;
1708
1709
egg_list_box_drag_unhighlight_widget (list_box);
1710
gtk_drag_highlight (child);
1711
1712
old_highlight = priv->drag_highlighted_widget;
1713
priv->drag_highlighted_widget = g_object_ref (child);
1714
if (old_highlight)
1715
g_object_unref (old_highlight);
1716
}
1717
1718
static void
1719
egg_list_box_real_drag_leave (GtkWidget *widget, GdkDragContext *context, guint time_)
1720
{
1721
EggListBox *list_box = EGG_LIST_BOX (widget);
1722
EggListBoxPrivate *priv = list_box->priv;
1723
1724
egg_list_box_drag_unhighlight_widget (list_box);
1725
if (priv->auto_scroll_timeout_id != 0) {
1726
g_source_remove (priv->auto_scroll_timeout_id);
1727
priv->auto_scroll_timeout_id = 0;
1728
}
1729
}
1730
1731
typedef struct
1732
{
1733
EggListBox *list_box;
1734
gint move;
1735
} MoveData;
1736
1737
static void
1738
move_data_free (MoveData *data)
1739
{
1740
g_slice_free (MoveData, data);
1741
}
1742
1743
static gboolean
1744
drag_motion_timeout (MoveData *data)
1745
{
1746
EggListBox *list_box = data->list_box;
1747
EggListBoxPrivate *priv = list_box->priv;
1748
1749
gtk_adjustment_set_value (priv->adjustment,
1750
gtk_adjustment_get_value (priv->adjustment) +
1751
gtk_adjustment_get_step_increment (priv->adjustment) * data->move);
1752
return TRUE;
1753
}
1754
1755
static gboolean
1756
egg_list_box_real_drag_motion (GtkWidget *widget, GdkDragContext *context,
1757
gint x, gint y, guint time_)
1758
{
1759
EggListBox *list_box = EGG_LIST_BOX (widget);
1760
EggListBoxPrivate *priv = list_box->priv;
1761
int move;
1762
MoveData *data;
1763
gdouble size;
1764
1765
/* Auto-scroll during Dnd if cursor is moving into the top/bottom portion of the
1766
* box. */
1767
if (priv->auto_scroll_timeout_id != 0)
1768
{
1769
g_source_remove (priv->auto_scroll_timeout_id);
1770
priv->auto_scroll_timeout_id = 0;
1771
}
1772
1773
if (priv->adjustment == NULL)
1774
return FALSE;
1775
1776
/* Part of the view triggering auto-scroll */
1777
size = 30;
1778
move = 0;
1779
1780
if (y < (gtk_adjustment_get_value (priv->adjustment) + size))
1781
{
1782
/* Scroll up */
1783
move = -1;
1784
}
1785
else if (y > ((gtk_adjustment_get_value (priv->adjustment) + gtk_adjustment_get_page_size (priv->adjustment)) - size))
1786
{
1787
/* Scroll down */
1788
move = 1;
1789
}
1790
1791
if (move == 0)
1792
return FALSE;
1793
1794
data = g_slice_new0 (MoveData);
1795
data->list_box = list_box;
1796
1797
priv->auto_scroll_timeout_id =
1798
g_timeout_add_full (G_PRIORITY_DEFAULT, 150, (GSourceFunc)drag_motion_timeout,
1799
data, (GDestroyNotify) move_data_free);
1800
1801
return FALSE;
1802
}
1803
1804
static void
1805
egg_list_box_real_activate_cursor_child (EggListBox *list_box)
1806
{
1807
EggListBoxPrivate *priv = list_box->priv;
1808
1809
egg_list_box_select_and_activate (list_box, priv->cursor_child);
1810
}
1811
1812
static void
1813
egg_list_box_real_toggle_cursor_child (EggListBox *list_box)
1814
{
1815
EggListBoxPrivate *priv = list_box->priv;
1816
1817
if (priv->cursor_child == NULL)
1818
return;
1819
1820
if (priv->selection_mode == GTK_SELECTION_SINGLE &&
1821
priv->selected_child == priv->cursor_child)
1822
egg_list_box_update_selected (list_box, NULL);
1823
else
1824
egg_list_box_select_and_activate (list_box, priv->cursor_child);
1825
}
1826
1827
static void
1828
egg_list_box_real_move_cursor (EggListBox *list_box,
1829
GtkMovementStep step,
1830
gint count)
1831
{
1832
EggListBoxPrivate *priv = list_box->priv;
1833
GdkModifierType state;
1834
gboolean modify_selection_pressed;
1835
EggListBoxChildInfo *child;
1836
GdkModifierType modify_mod_mask;
1837
EggListBoxChildInfo *prev;
1838
EggListBoxChildInfo *next;
1839
gint page_size;
1840
GSequenceIter *iter;
1841
gint start_y;
1842
gint end_y;
1843
1844
modify_selection_pressed = FALSE;
1845
1846
if (gtk_get_current_event_state (&state))
1847
{
1848
modify_mod_mask = gtk_widget_get_modifier_mask (GTK_WIDGET (list_box),
1849
GDK_MODIFIER_INTENT_MODIFY_SELECTION);
1850
if ((state & modify_mod_mask) == modify_mod_mask)
1851
modify_selection_pressed = TRUE;
1852
}
1853
1854
child = NULL;
1855
switch (step)
1856
{
1857
case GTK_MOVEMENT_BUFFER_ENDS:
1858
if (count < 0)
1859
child = egg_list_box_get_first_visible (list_box);
1860
else
1861
child = egg_list_box_get_last_visible (list_box);
1862
break;
1863
case GTK_MOVEMENT_DISPLAY_LINES:
1864
if (priv->cursor_child != NULL)
1865
{
1866
iter = priv->cursor_child->iter;
1867
1868
while (count < 0 && iter != NULL)
1869
{
1870
iter = egg_list_box_get_previous_visible (list_box, iter);
1871
count = count + 1;
1872
}
1873
while (count > 0 && iter != NULL)
1874
{
1875
iter = egg_list_box_get_next_visible (list_box, iter);
1876
count = count - 1;
1877
}
1878
1879
if (iter != NULL && !g_sequence_iter_is_end (iter))
1880
child = g_sequence_get (iter);
1881
}
1882
break;
1883
case GTK_MOVEMENT_PAGES:
1884
page_size = 100;
1885
if (priv->adjustment != NULL)
1886
page_size = gtk_adjustment_get_page_increment (priv->adjustment);
1887
1888
if (priv->cursor_child != NULL)
1889
{
1890
start_y = priv->cursor_child->y;
1891
end_y = start_y;
1892
iter = priv->cursor_child->iter;
1893
1894
child = priv->cursor_child;
1895
if (count < 0)
1896
{
1897
/* Up */
1898
while (iter != NULL && !g_sequence_iter_is_begin (iter))
1899
{
1900
iter = egg_list_box_get_previous_visible (list_box, iter);
1901
if (iter == NULL)
1902
break;
1903
1904
prev = g_sequence_get (iter);
1905
if (prev->y < start_y - page_size)
1906
break;
1907
1908
child = prev;
1909
}
1910
}
1911
else
1912
{
1913
/* Down */
1914
while (iter != NULL && !g_sequence_iter_is_end (iter))
1915
{
1916
iter = egg_list_box_get_next_visible (list_box, iter);
1917
if (g_sequence_iter_is_end (iter))
1918
break;
1919
1920
next = g_sequence_get (iter);
1921
if (next->y > start_y + page_size)
1922
break;
1923
1924
child = next;
1925
}
1926
}
1927
end_y = child->y;
1928
if (end_y != start_y && priv->adjustment != NULL)
1929
gtk_adjustment_set_value (priv->adjustment,
1930
gtk_adjustment_get_value (priv->adjustment) +
1931
end_y - start_y);
1932
}
1933
break;
1934
default:
1935
return;
1936
}
1937
1938
if (child == NULL)
1939
{
1940
gtk_widget_error_bell (GTK_WIDGET (list_box));
1941
return;
1942
}
1943
1944
egg_list_box_update_cursor (list_box, child);
1945
if (!modify_selection_pressed)
1946
egg_list_box_update_selected (list_box, child);
1947
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1