« back to all changes in this revision
Viewing changes to os/os-scrollbar.c
- browse files at revision 101
- compare with another revision
- download diff
- download tarball
- view history from revision 101
- Committer: Loïc Molinari
- Date: 2011-03-01 02:37:10 UTC
- Revision ID: loic.molinari@canonical.com-20110301023710-nc7uu4el1o5mzfzq
Cleaned up library code and naming
- files added:
- os/os-private.h
- pkgconfig
- files removed:
- os/overlay-pager.h
- files renamed:
- os/overlay-pager.c => os/os-pager.c
- os/overlay-scrollbar.c => os/os-scrollbar.c
- os/overlay-scrollbar.h => os/os-scrollbar.h
- os/overlay-thumb.c => os/os-thumb.c
- os/overlay-scrollbar.pc.in => pkgconfig/overlay-scrollbar.pc.in
- files modified:
- os/Makefile.am
added
removed
os/os-scrollbar.c
1
/* liboverlay-scrollbar
2
* Copyright (C) 2011 Canonical Ltd
1
/* overlay-scrollbar
2
*
3
* Copyright © 2011 Canonical Ltd
3
4
*
4
5
* This library is free software; you can redistribute it and/or
5
6
* modify it under the terms of the GNU Library General Public
17
18
* Boston, MA 02111-1307, USA.
18
19
*
19
20
* Authored by Andrea Cimitan <andrea.cimitan@canonical.com>
20
*
21
21
*/
22
22
23
#ifndef HAVE_CONFIG_H
24
#include "config.h"
25
#endif /* HAVE_CONFIG_H */
26
27
#include "os-scrollbar.h"
28
#include "os-private.h"
23
29
#include <cairo-xlib.h>
24
#include <gtk/gtk.h>
25
30
#include <gdk/gdkx.h>
26
31
#include <X11/X.h>
27
32
#include <X11/Xlib.h>
28
33
29
#include "overlay-scrollbar.h"
30
#include "overlay-scrollbar-cairo-support.h"
31
#include "overlay-scrollbar-support.h"
32
#include "overlay-pager.h"
33
#include "overlay-thumb.h"
34
35
#define OVERLAY_SCROLLBAR_WIDTH 15 /* width/height of the overlay scrollbar, in pixels */
36
#define OVERLAY_SCROLLBAR_HEIGHT 80 /* height/width of the overlay scrollbar, in pixels */
34
#define OS_SCROLLBAR_WIDTH 15 /* width/height of the overlay scrollbar, in pixels */
35
#define OS_SCROLLBAR_HEIGHT 80 /* height/width of the overlay scrollbar, in pixels */
37
36
#define PROXIMITY_WIDTH 40 /* width/height of the proximity effect, in pixels */
38
37
#define TIMEOUT_HIDE 1000 /* timeout before hiding, in milliseconds */
39
38
40
#define OVERLAY_SCROLLBAR_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), OS_TYPE_OVERLAY_SCROLLBAR, OverlayScrollbarPrivate))
41
42
typedef struct _OverlayScrollbarPrivate OverlayScrollbarPrivate;
43
44
struct _OverlayScrollbarPrivate
39
#define OS_SCROLLBAR_GET_PRIVATE(obj) \
40
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), OS_TYPE_SCROLLBAR, OsScrollbarPrivate))
41
42
typedef struct _OsScrollbarPrivate OsScrollbarPrivate;
43
44
struct _OsScrollbarPrivate
45
45
{
46
46
GdkRectangle trough;
47
47
GdkRectangle overlay;
78
78
gint pointer_y;
79
79
};
80
80
81
G_DEFINE_TYPE (OverlayScrollbar, overlay_scrollbar, GTK_TYPE_SCROLLBAR);
81
G_DEFINE_TYPE (OsScrollbar, os_scrollbar, GTK_TYPE_SCROLLBAR);
82
83
/* Present a X11 window. */
84
static void
85
os_present_window_with_timestamp (Display *default_display,
86
Screen *screen,
87
gint xid,
88
guint32 timestamp)
89
{
90
Display *display;
91
Window root;
92
XEvent xev;
93
94
if (timestamp == 0)
95
g_warning ("Received a timestamp of 0; window activation may not "
96
"function properly.\n");
97
98
display = DisplayOfScreen (screen);
99
root = RootWindowOfScreen (screen);
100
101
xev.xclient.type = ClientMessage;
102
xev.xclient.serial = 0;
103
xev.xclient.send_event = True;
104
xev.xclient.display = display;
105
xev.xclient.window = xid;
106
xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_ACTIVE_WINDOW");
107
xev.xclient.format = 32;
108
xev.xclient.data.l[0] = 1;
109
xev.xclient.data.l[1] = timestamp;
110
xev.xclient.data.l[2] = 0;
111
xev.xclient.data.l[3] = 0;
112
xev.xclient.data.l[4] = 0;
113
114
gdk_error_trap_push ();
115
XSendEvent (display,
116
root,
117
False,
118
SubstructureRedirectMask | SubstructureNotifyMask,
119
&xev);
120
XSync (default_display, False);
121
gdk_error_trap_pop ();
122
}
123
124
/* Present a GDK window. */
125
static void
126
os_present_gdk_window_with_timestamp (GtkWidget *widget,
127
guint32 timestamp)
128
{
129
os_present_window_with_timestamp (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
130
GDK_SCREEN_XSCREEN (gtk_widget_get_screen (widget)),
131
GDK_WINDOW_XID (gtk_widget_get_window (widget)),
132
timestamp);
133
}
82
134
83
135
/* SUBCLASS FUNCTIONS */
84
static gboolean overlay_scrollbar_expose_event (GtkWidget *widget,
136
static gboolean os_scrollbar_expose_event (GtkWidget *widget,
85
137
GdkEventExpose *event);
86
138
87
static void overlay_scrollbar_hide (GtkWidget *widget);
88
89
static void overlay_scrollbar_map (GtkWidget *widget);
90
91
static void overlay_scrollbar_parent_set (GtkWidget *widget,
139
static void os_scrollbar_hide (GtkWidget *widget);
140
141
static void os_scrollbar_map (GtkWidget *widget);
142
143
static void os_scrollbar_parent_set (GtkWidget *widget,
92
144
GtkWidget *old_parent);
93
145
94
static void overlay_scrollbar_realize (GtkWidget *widget);
95
96
static void overlay_scrollbar_show (GtkWidget *widget);
97
98
static void overlay_scrollbar_unmap (GtkWidget *widget);
99
100
static void overlay_scrollbar_unrealize (GtkWidget *widget);
146
static void os_scrollbar_realize (GtkWidget *widget);
147
148
static void os_scrollbar_show (GtkWidget *widget);
149
150
static void os_scrollbar_unmap (GtkWidget *widget);
151
152
static void os_scrollbar_unrealize (GtkWidget *widget);
101
153
102
154
/* GOBJECT CLASS FUNCTIONS */
103
static void overlay_scrollbar_dispose (GObject *object);
155
static void os_scrollbar_dispose (GObject *object);
104
156
105
157
/* HELPER FUNCTIONS */
106
static void overlay_scrollbar_calc_layout_pager (OverlayScrollbar *scrollbar,
158
static void os_scrollbar_calc_layout_pager (OsScrollbar *scrollbar,
107
159
gdouble adjustment_value);
108
160
109
static gdouble overlay_scrollbar_coord_to_value (OverlayScrollbar *scrollbar,
161
static gdouble os_scrollbar_coord_to_value (OsScrollbar *scrollbar,
110
162
gint coord);
111
163
112
static gboolean overlay_scrollbar_hide_thumb (gpointer user_data);
164
static gboolean os_scrollbar_hide_thumb (gpointer user_data);
113
165
114
static void overlay_scrollbar_move (OverlayScrollbar *scrollbar,
166
static void os_scrollbar_move (OsScrollbar *scrollbar,
115
167
gint mouse_x,
116
168
gint mouse_y);
117
169
118
static void overlay_scrollbar_notify_adjustment_cb (GObject *object,
170
static void os_scrollbar_notify_adjustment_cb (GObject *object,
119
171
gpointer user_data);
120
172
121
static void overlay_scrollbar_notify_orientation_cb (GObject *object,
173
static void os_scrollbar_notify_orientation_cb (GObject *object,
122
174
gpointer user_data);
123
175
124
static void overlay_scrollbar_store_window_position (OverlayScrollbar *scrollbar);
176
static void os_scrollbar_store_window_position (OsScrollbar *scrollbar);
125
177
126
static void overlay_scrollbar_swap_adjustment (OverlayScrollbar *scrollbar,
178
static void os_scrollbar_swap_adjustment (OsScrollbar *scrollbar,
127
179
GtkAdjustment *adjustment);
128
180
129
static void overlay_scrollbar_swap_parent (OverlayScrollbar *scrollbar,
181
static void os_scrollbar_swap_parent (OsScrollbar *scrollbar,
130
182
GtkWidget *parent);
131
183
132
static void overlay_scrollbar_swap_thumb (OverlayScrollbar *scrollbar,
184
static void os_scrollbar_swap_thumb (OsScrollbar *scrollbar,
133
185
GtkWidget *thumb);
134
186
135
static void overlay_scrollbar_toplevel_connect (OverlayScrollbar *scrollbar);
187
static void os_scrollbar_toplevel_connect (OsScrollbar *scrollbar);
136
188
137
189
/* THUMB FUNCTIONS */
138
static gboolean overlay_thumb_button_press_event_cb (GtkWidget *widget,
190
static gboolean os_thumb_button_press_event_cb (GtkWidget *widget,
139
191
GdkEventButton *event,
140
192
gpointer user_data);
141
193
142
static gboolean overlay_thumb_button_release_event_cb (GtkWidget *widget,
194
static gboolean os_thumb_button_release_event_cb (GtkWidget *widget,
143
195
GdkEventButton *event,
144
196
gpointer user_data);
145
197
146
static gboolean overlay_thumb_enter_notify_event_cb (GtkWidget *widget,
147
GdkEventCrossing *event,
148
gpointer user_data);
149
150
static gboolean overlay_thumb_leave_notify_event_cb (GtkWidget *widget,
151
GdkEventCrossing *event,
152
gpointer user_data);
153
154
static gboolean overlay_thumb_motion_notify_event_cb (GtkWidget *widget,
198
static gboolean os_thumb_enter_notify_event_cb (GtkWidget *widget,
199
GdkEventCrossing *event,
200
gpointer user_data);
201
202
static gboolean os_thumb_leave_notify_event_cb (GtkWidget *widget,
203
GdkEventCrossing *event,
204
gpointer user_data);
205
206
static gboolean os_thumb_motion_notify_event_cb (GtkWidget *widget,
155
207
GdkEventMotion *event,
156
208
gpointer user_data);
157
209
158
210
/* OVERLAY FUNCTIONS */
159
static void overlay_move (OverlayScrollbar *scrollbar);
211
static void overlay_move (OsScrollbar *scrollbar);
160
212
161
static void overlay_resize_window (OverlayScrollbar *scrollbar);
213
static void overlay_resize_window (OsScrollbar *scrollbar);
162
214
163
215
/* ADJUSTMENT FUNCTIONS */
164
216
static void adjustment_value_changed_cb (GtkAdjustment *adjustment,
188
240
189
241
/* SUBCLASS FUNCTIONS */
190
242
/**
191
* overlay_scrollbar_class_init:
243
* os_scrollbar_class_init:
192
244
* class init function
193
245
**/
194
246
static void
195
overlay_scrollbar_class_init (OverlayScrollbarClass *class)
247
os_scrollbar_class_init (OsScrollbarClass *class)
196
248
{
197
DEBUG
198
249
GObjectClass *gobject_class;
199
250
GtkWidgetClass *widget_class;
200
251
201
252
gobject_class = G_OBJECT_CLASS (class);
202
253
widget_class = GTK_WIDGET_CLASS (class);
203
254
204
widget_class->expose_event = overlay_scrollbar_expose_event;
205
widget_class->hide = overlay_scrollbar_hide;
206
widget_class->map = overlay_scrollbar_map;
207
widget_class->realize = overlay_scrollbar_realize;
208
widget_class->parent_set = overlay_scrollbar_parent_set;
209
widget_class->show = overlay_scrollbar_show;
210
widget_class->unmap = overlay_scrollbar_unmap;
211
widget_class->unrealize = overlay_scrollbar_unrealize;
212
213
gobject_class->dispose = overlay_scrollbar_dispose;
214
215
g_type_class_add_private (gobject_class, sizeof (OverlayScrollbarPrivate));
255
widget_class->expose_event = os_scrollbar_expose_event;
256
widget_class->hide = os_scrollbar_hide;
257
widget_class->map = os_scrollbar_map;
258
widget_class->realize = os_scrollbar_realize;
259
widget_class->parent_set = os_scrollbar_parent_set;
260
widget_class->show = os_scrollbar_show;
261
widget_class->unmap = os_scrollbar_unmap;
262
widget_class->unrealize = os_scrollbar_unrealize;
263
264
gobject_class->dispose = os_scrollbar_dispose;
265
266
g_type_class_add_private (gobject_class, sizeof (OsScrollbarPrivate));
216
267
}
217
268
218
269
/**
219
* overlay_scrollbar_init:
270
* os_scrollbar_init:
220
271
* init function
221
272
**/
222
273
static void
223
overlay_scrollbar_init (OverlayScrollbar *scrollbar)
274
os_scrollbar_init (OsScrollbar *scrollbar)
224
275
{
225
DEBUG
226
OverlayScrollbarPrivate *priv;
276
OsScrollbarPrivate *priv;
227
277
228
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
278
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
229
279
230
280
priv->can_hide = TRUE;
231
281
priv->can_rgba = FALSE;
232
282
priv->proximity = FALSE;
233
283
234
284
g_signal_connect (G_OBJECT (scrollbar), "notify::adjustment",
235
G_CALLBACK (overlay_scrollbar_notify_adjustment_cb), NULL);
285
G_CALLBACK (os_scrollbar_notify_adjustment_cb), NULL);
236
286
237
287
g_signal_connect (G_OBJECT (scrollbar), "notify::orientation",
238
G_CALLBACK (overlay_scrollbar_notify_orientation_cb), NULL);
288
G_CALLBACK (os_scrollbar_notify_orientation_cb), NULL);
239
289
}
240
290
241
291
/**
242
* overlay_scrollbar_expose_event:
292
* os_scrollbar_expose_event:
243
293
* override class function
244
294
**/
245
295
static gboolean
246
overlay_scrollbar_expose_event (GtkWidget *widget,
296
os_scrollbar_expose_event (GtkWidget *widget,
247
297
GdkEventExpose *event)
248
298
{
249
DEBUG
250
299
return TRUE;
251
300
}
252
301
253
302
/**
254
* overlay_scrollbar_hide:
303
* os_scrollbar_hide:
255
304
* override class function
256
305
*/
257
306
static void
258
overlay_scrollbar_hide (GtkWidget *widget)
307
os_scrollbar_hide (GtkWidget *widget)
259
308
{
260
DEBUG
261
OverlayScrollbarPrivate *priv;
309
OsScrollbarPrivate *priv;
262
310
263
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (widget));
311
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (widget));
264
312
265
313
priv->proximity = FALSE;
266
314
267
GTK_WIDGET_CLASS (overlay_scrollbar_parent_class)->hide (widget);
315
GTK_WIDGET_CLASS (os_scrollbar_parent_class)->hide (widget);
268
316
269
317
if (priv->pager != NULL)
270
318
{
271
overlay_pager_hide (OVERLAY_PAGER (priv->pager));
319
os_pager_hide (OS_PAGER (priv->pager));
272
320
}
273
321
}
274
322
275
323
/**
276
* overlay_scrollbar_map:
324
* os_scrollbar_map:
277
325
* override class function
278
326
**/
279
327
static void
280
overlay_scrollbar_map (GtkWidget *widget)
328
os_scrollbar_map (GtkWidget *widget)
281
329
{
282
DEBUG
283
OverlayScrollbarPrivate *priv;
330
OsScrollbarPrivate *priv;
284
331
285
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (widget));
332
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (widget));
286
333
287
334
priv->proximity = TRUE;
288
335
289
GTK_WIDGET_CLASS (overlay_scrollbar_parent_class)->map (widget);
336
GTK_WIDGET_CLASS (os_scrollbar_parent_class)->map (widget);
290
337
291
338
if (priv->pager != NULL)
292
339
{
293
overlay_pager_show (OVERLAY_PAGER (priv->pager));
340
os_pager_show (OS_PAGER (priv->pager));
294
341
}
295
342
#if 0
296
343
Display *display;
343
390
}
344
391
345
392
/**
346
* overlay_scrollbar_parent_set:
393
* os_scrollbar_parent_set:
347
394
* override class function
348
395
**/
349
396
static void
350
overlay_scrollbar_parent_set (GtkWidget *widget,
397
os_scrollbar_parent_set (GtkWidget *widget,
351
398
GtkWidget *old_parent)
352
399
{
353
DEBUG
354
overlay_scrollbar_swap_parent (OVERLAY_SCROLLBAR (widget), gtk_widget_get_parent (widget));
355
}
356
357
/**
358
* overlay_scrollbar_realize:
359
* override class function
360
*/
361
static void
362
overlay_scrollbar_realize (GtkWidget *widget)
363
{
364
DEBUG
365
GTK_WIDGET_CLASS (overlay_scrollbar_parent_class)->realize (widget);
366
}
367
368
/**
369
* overlay_scrollbar_show:
370
* override class function
371
*/
372
static void
373
overlay_scrollbar_show (GtkWidget *widget)
374
{
375
DEBUG
376
OverlayScrollbarPrivate *priv;
377
378
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (widget));
400
os_scrollbar_swap_parent (OS_SCROLLBAR (widget), gtk_widget_get_parent (widget));
401
}
402
403
/**
404
* os_scrollbar_realize:
405
* override class function
406
*/
407
static void
408
os_scrollbar_realize (GtkWidget *widget)
409
{
410
GTK_WIDGET_CLASS (os_scrollbar_parent_class)->realize (widget);
411
}
412
413
/**
414
* os_scrollbar_show:
415
* override class function
416
*/
417
static void
418
os_scrollbar_show (GtkWidget *widget)
419
{
420
OsScrollbarPrivate *priv;
421
422
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (widget));
379
423
380
424
priv->proximity = TRUE;
381
425
382
GTK_WIDGET_CLASS (overlay_scrollbar_parent_class)->show (widget);
426
GTK_WIDGET_CLASS (os_scrollbar_parent_class)->show (widget);
383
427
384
428
if (priv->pager != NULL)
385
429
{
386
overlay_pager_show (OVERLAY_PAGER (priv->pager));
430
os_pager_show (OS_PAGER (priv->pager));
387
431
}
388
432
}
389
433
390
434
/**
391
* overlay_scrollbar_unmap:
435
* os_scrollbar_unmap:
392
436
* override class function
393
437
**/
394
438
static void
395
overlay_scrollbar_unmap (GtkWidget *widget)
439
os_scrollbar_unmap (GtkWidget *widget)
396
440
{
397
DEBUG
398
OverlayScrollbarPrivate *priv;
441
OsScrollbarPrivate *priv;
399
442
400
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (widget));
443
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (widget));
401
444
402
445
priv->proximity = FALSE;
403
446
404
GTK_WIDGET_CLASS (overlay_scrollbar_parent_class)->unmap (widget);
447
GTK_WIDGET_CLASS (os_scrollbar_parent_class)->unmap (widget);
405
448
406
449
if (priv->pager != NULL)
407
450
{
408
overlay_pager_hide (OVERLAY_PAGER (priv->pager));
451
os_pager_hide (OS_PAGER (priv->pager));
409
452
}
410
453
}
411
454
412
455
/**
413
* overlay_scrollbar_unrealize:
456
* os_scrollbar_unrealize:
414
457
* override class function
415
458
*/
416
459
static void
417
overlay_scrollbar_unrealize (GtkWidget *widget)
460
os_scrollbar_unrealize (GtkWidget *widget)
418
461
{
419
DEBUG
420
GTK_WIDGET_CLASS (overlay_scrollbar_parent_class)->unrealize (widget);
462
GTK_WIDGET_CLASS (os_scrollbar_parent_class)->unrealize (widget);
421
463
}
422
464
423
465
424
466
/* GOBJECT CLASS FUNCTIONS */
425
467
/**
426
* overlay_scrollbar_dispose:
468
* os_scrollbar_dispose:
427
469
* override class function
428
470
*/
429
471
static void
430
overlay_scrollbar_dispose (GObject *object)
472
os_scrollbar_dispose (GObject *object)
431
473
{
432
DEBUG
433
OverlayScrollbarPrivate *priv = OVERLAY_SCROLLBAR_GET_PRIVATE (object);
474
OsScrollbarPrivate *priv = OS_SCROLLBAR_GET_PRIVATE (object);
434
475
435
overlay_scrollbar_swap_adjustment (OVERLAY_SCROLLBAR (object), NULL);
436
overlay_scrollbar_swap_parent (OVERLAY_SCROLLBAR (object), NULL);
437
overlay_scrollbar_swap_thumb (OVERLAY_SCROLLBAR (object), NULL);
476
os_scrollbar_swap_adjustment (OS_SCROLLBAR (object), NULL);
477
os_scrollbar_swap_parent (OS_SCROLLBAR (object), NULL);
478
os_scrollbar_swap_thumb (OS_SCROLLBAR (object), NULL);
438
479
439
480
if (priv->pager != NULL)
440
481
{
442
483
priv->pager = NULL;
443
484
}
444
485
445
G_OBJECT_CLASS (overlay_scrollbar_parent_class)->dispose (object);
486
G_OBJECT_CLASS (os_scrollbar_parent_class)->dispose (object);
446
487
}
447
488
448
489
/* PUBLIC FUNCTIONS*/
449
490
/**
450
* overlay_scrollbar_new:
491
* os_scrollbar_new:
451
492
* @orientation: the #GtkOrientation
452
493
* @adjustment: the pointer to the #GtkAdjustment to connect
453
494
*
456
497
* Returns: the new overlay scrollbar as a #GtkWidget
457
498
*/
458
499
GtkWidget*
459
overlay_scrollbar_new (GtkOrientation orientation,
460
GtkAdjustment *adjustment)
500
os_scrollbar_new (GtkOrientation orientation,
501
GtkAdjustment *adjustment)
461
502
{
462
DEBUG
463
return g_object_new (OS_TYPE_OVERLAY_SCROLLBAR,
464
"orientation", orientation,
465
"adjustment", adjustment,
466
NULL);
503
return g_object_new (OS_TYPE_SCROLLBAR, "orientation", orientation,
504
"adjustment", adjustment, NULL);
467
505
}
468
506
469
507
/* HELPER FUNCTIONS */
470
508
/**
471
* overlay_scrollbar_calc_layout_pager:
509
* os_scrollbar_calc_layout_pager:
472
510
* calculate layout and store info
473
511
**/
474
512
static void
475
overlay_scrollbar_calc_layout_pager (OverlayScrollbar *scrollbar,
513
os_scrollbar_calc_layout_pager (OsScrollbar *scrollbar,
476
514
gdouble adjustment_value)
477
515
{
478
DEBUG
479
OverlayScrollbarPrivate *priv;
516
OsScrollbarPrivate *priv;
480
517
481
518
gint tmp_height;
482
519
483
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
520
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
484
521
tmp_height = priv->overlay.height;
485
522
486
523
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
515
552
priv->overlay.y = y;
516
553
priv->overlay.height = height;
517
554
518
if (tmp_height != height);
555
if (tmp_height != height)
519
556
{
520
557
if (priv->pager != NULL)
521
558
{
559
596
}
560
597
561
598
/**
562
* overlay_scrollbar_calc_layout_slider:
563
* calculate OverlayScrollbar layout and store info
599
* os_scrollbar_calc_layout_slider:
600
* calculate OsScrollbar layout and store info
564
601
**/
565
602
static void
566
overlay_scrollbar_calc_layout_slider (OverlayScrollbar *scrollbar,
603
os_scrollbar_calc_layout_slider (OsScrollbar *scrollbar,
567
604
gdouble adjustment_value)
568
605
{
569
DEBUG
570
OverlayScrollbarPrivate *priv;
606
OsScrollbarPrivate *priv;
571
607
572
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
608
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
573
609
574
610
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
575
611
{
618
654
}
619
655
620
656
/**
621
* overlay_scrollbar_coord_to_value:
657
* os_scrollbar_coord_to_value:
622
658
* traduce pixels into proper values
623
659
**/
624
660
static gdouble
625
overlay_scrollbar_coord_to_value (OverlayScrollbar *scrollbar,
661
os_scrollbar_coord_to_value (OsScrollbar *scrollbar,
626
662
gint coord)
627
663
{
628
DEBUG
629
OverlayScrollbarPrivate *priv;
664
OsScrollbarPrivate *priv;
630
665
gdouble frac;
631
666
gdouble value;
632
667
gint trough_length;
633
668
gint trough_start;
634
669
gint slider_length;
635
670
636
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
671
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
637
672
638
673
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
639
674
{
664
699
}
665
700
666
701
/**
667
* overlay_scrollbar_hide_thumb:
702
* os_scrollbar_hide_thumb:
668
703
* hide if it's ok to hide
669
704
**/
670
705
static gboolean
671
overlay_scrollbar_hide_thumb (gpointer user_data)
706
os_scrollbar_hide_thumb (gpointer user_data)
672
707
{
673
DEBUG
674
OverlayScrollbar *scrollbar;
675
OverlayScrollbarPrivate *priv;
708
OsScrollbar *scrollbar;
709
OsScrollbarPrivate *priv;
676
710
677
711
scrollbar = user_data;
678
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
712
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
679
713
680
714
if (priv->can_hide)
681
715
{
687
721
}
688
722
689
723
/**
690
* overlay_scrollbar_move:
724
* os_scrollbar_move:
691
725
* move the scrollbar
692
726
**/
693
727
static void
694
overlay_scrollbar_move (OverlayScrollbar *scrollbar,
728
os_scrollbar_move (OsScrollbar *scrollbar,
695
729
gint mouse_x,
696
730
gint mouse_y)
697
731
{
698
DEBUG
699
OverlayScrollbarPrivate *priv;
732
OsScrollbarPrivate *priv;
700
733
gint delta;
701
734
gint c;
702
735
gdouble new_value;
703
736
704
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
737
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
705
738
706
739
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
707
740
delta = mouse_y - priv->slide_initial_coordinate;
710
743
711
744
c = priv->slide_initial_slider_position + delta;
712
745
713
new_value = overlay_scrollbar_coord_to_value (scrollbar, c);
746
new_value = os_scrollbar_coord_to_value (scrollbar, c);
714
747
715
748
gtk_adjustment_set_value (priv->adjustment, new_value);
716
749
gtk_adjustment_value_changed (priv->adjustment);
717
750
}
718
751
719
752
/**
720
* overlay_scrollbar_notify_adjustment_cb:
753
* os_scrollbar_notify_adjustment_cb:
721
754
* callback to the adjustment notification for the gobject
722
755
*/
723
756
static void
724
overlay_scrollbar_notify_adjustment_cb (GObject *object,
757
os_scrollbar_notify_adjustment_cb (GObject *object,
725
758
gpointer user_data)
726
759
{
727
DEBUG
728
OverlayScrollbarPrivate *priv;
729
730
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (object));
731
732
overlay_scrollbar_swap_adjustment (OVERLAY_SCROLLBAR (object), gtk_range_get_adjustment (GTK_RANGE (object)));
760
OsScrollbarPrivate *priv;
761
762
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (object));
763
764
os_scrollbar_swap_adjustment (OS_SCROLLBAR (object), gtk_range_get_adjustment (GTK_RANGE (object)));
733
765
}
734
766
735
767
/**
736
* overlay_scrollbar_notify_orientation_cb:
768
* os_scrollbar_notify_orientation_cb:
737
769
* callback to the orientation notification for the gobject
738
770
*/
739
771
static void
740
overlay_scrollbar_notify_orientation_cb (GObject *object,
772
os_scrollbar_notify_orientation_cb (GObject *object,
741
773
gpointer user_data)
742
774
{
743
DEBUG
744
OverlayScrollbarPrivate *priv;
775
OsScrollbarPrivate *priv;
745
776
746
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (object));
777
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (object));
747
778
748
779
priv->orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (object));
749
780
750
overlay_scrollbar_swap_thumb (OVERLAY_SCROLLBAR (object), overlay_thumb_new (priv->orientation));
781
os_scrollbar_swap_thumb (OS_SCROLLBAR (object), os_thumb_new (priv->orientation));
751
782
}
752
783
753
784
/**
754
* overlay_scrollbar_store_window_position:
785
* os_scrollbar_store_window_position:
755
786
* store scrollbar window position
756
787
**/
757
788
static void
758
overlay_scrollbar_store_window_position (OverlayScrollbar *scrollbar)
789
os_scrollbar_store_window_position (OsScrollbar *scrollbar)
759
790
{
760
DEBUG
761
OverlayScrollbarPrivate *priv;
791
OsScrollbarPrivate *priv;
762
792
gint win_x, win_y;
763
793
764
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
794
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
765
795
766
796
if (GDK_IS_WINDOW (gtk_widget_get_window (priv->parent)))
767
797
gdk_window_get_position (gtk_widget_get_window (priv->parent), &win_x, &win_y);
779
809
}
780
810
781
811
/**
782
* overlay_scrollbar_swap_adjustment:
812
* os_scrollbar_swap_adjustment:
783
813
* swap the adjustment pointer
784
814
*/
785
815
static void
786
overlay_scrollbar_swap_adjustment (OverlayScrollbar *scrollbar,
816
os_scrollbar_swap_adjustment (OsScrollbar *scrollbar,
787
817
GtkAdjustment *adjustment)
788
818
{
789
DEBUG
790
OverlayScrollbarPrivate *priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
819
OsScrollbarPrivate *priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
791
820
792
821
if (priv->adjustment != NULL)
793
822
{
809
838
}
810
839
811
840
/**
812
* overlay_scrollbar_swap_parent:
841
* os_scrollbar_swap_parent:
813
842
* swap the parent pointer
814
843
*/
815
844
static void
816
overlay_scrollbar_swap_parent (OverlayScrollbar *scrollbar,
845
os_scrollbar_swap_parent (OsScrollbar *scrollbar,
817
846
GtkWidget *parent)
818
847
{
819
DEBUG
820
OverlayScrollbarPrivate *priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
848
OsScrollbarPrivate *priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
821
849
822
850
if (priv->parent != NULL)
823
851
{
843
871
}
844
872
845
873
/**
846
* overlay_scrollbar_swap_thumb:
874
* os_scrollbar_swap_thumb:
847
875
* swap the thumb pointer
848
876
*/
849
877
static void
850
overlay_scrollbar_swap_thumb (OverlayScrollbar *scrollbar,
878
os_scrollbar_swap_thumb (OsScrollbar *scrollbar,
851
879
GtkWidget *thumb)
852
880
{
853
DEBUG
854
OverlayScrollbarPrivate *priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
881
OsScrollbarPrivate *priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
855
882
856
883
if (priv->thumb != NULL)
857
884
{
858
885
g_signal_handlers_disconnect_by_func (G_OBJECT (priv->thumb),
859
overlay_thumb_button_press_event_cb, scrollbar);
860
g_signal_handlers_disconnect_by_func (G_OBJECT (priv->thumb),
861
overlay_thumb_button_release_event_cb, scrollbar);
862
g_signal_handlers_disconnect_by_func (G_OBJECT (priv->thumb),
863
overlay_thumb_motion_notify_event_cb, scrollbar);
864
g_signal_handlers_disconnect_by_func (G_OBJECT (priv->thumb),
865
overlay_thumb_enter_notify_event_cb, scrollbar);
866
g_signal_handlers_disconnect_by_func (G_OBJECT (priv->thumb),
867
overlay_thumb_leave_notify_event_cb, scrollbar);
886
os_thumb_button_press_event_cb, scrollbar);
887
g_signal_handlers_disconnect_by_func (G_OBJECT (priv->thumb),
888
os_thumb_button_release_event_cb, scrollbar);
889
g_signal_handlers_disconnect_by_func (G_OBJECT (priv->thumb),
890
os_thumb_motion_notify_event_cb, scrollbar);
891
g_signal_handlers_disconnect_by_func (G_OBJECT (priv->thumb),
892
os_thumb_enter_notify_event_cb, scrollbar);
893
g_signal_handlers_disconnect_by_func (G_OBJECT (priv->thumb),
894
os_thumb_leave_notify_event_cb, scrollbar);
868
895
869
896
g_object_unref (priv->thumb);
870
897
}
876
903
g_object_ref_sink (priv->thumb);
877
904
878
905
g_signal_connect (G_OBJECT (priv->thumb), "button-press-event",
879
G_CALLBACK (overlay_thumb_button_press_event_cb), scrollbar);
906
G_CALLBACK (os_thumb_button_press_event_cb), scrollbar);
880
907
g_signal_connect (G_OBJECT (priv->thumb), "button-release-event",
881
G_CALLBACK (overlay_thumb_button_release_event_cb), scrollbar);
908
G_CALLBACK (os_thumb_button_release_event_cb), scrollbar);
882
909
g_signal_connect (G_OBJECT (priv->thumb), "motion-notify-event",
883
G_CALLBACK (overlay_thumb_motion_notify_event_cb), scrollbar);
910
G_CALLBACK (os_thumb_motion_notify_event_cb), scrollbar);
884
911
g_signal_connect (G_OBJECT (priv->thumb), "enter-notify-event",
885
G_CALLBACK (overlay_thumb_enter_notify_event_cb), scrollbar);
912
G_CALLBACK (os_thumb_enter_notify_event_cb), scrollbar);
886
913
g_signal_connect (G_OBJECT (priv->thumb), "leave-notify-event",
887
G_CALLBACK (overlay_thumb_leave_notify_event_cb), scrollbar);
914
G_CALLBACK (os_thumb_leave_notify_event_cb), scrollbar);
888
915
}
889
916
}
890
917
891
918
/**
892
* overlay_scrollbar_toplevel_connect:
919
* os_scrollbar_toplevel_connect:
893
920
* create elements, needs to me improved
894
921
*/
895
922
static void
896
overlay_scrollbar_toplevel_connect (OverlayScrollbar *scrollbar)
923
os_scrollbar_toplevel_connect (OsScrollbar *scrollbar)
897
924
{
898
DEBUG
899
OverlayScrollbarPrivate *priv;
925
OsScrollbarPrivate *priv;
900
926
gint x_pos, y_pos;
901
927
902
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (scrollbar));
928
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (scrollbar));
903
929
904
930
g_return_if_fail (priv->parent != NULL);
905
931
g_return_if_fail (GDK_IS_WINDOW (gtk_widget_get_window (priv->parent)));
913
939
914
940
gdk_window_get_position (gtk_widget_get_window (priv->parent), &x_pos, &y_pos);
915
941
916
overlay_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
942
os_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
917
943
918
944
gtk_window_move (GTK_WINDOW (priv->thumb), x_pos + priv->thumb_all.x, y_pos + priv->thumb_all.y);
919
945
923
949
priv->pager = NULL;
924
950
}
925
951
926
priv->pager = overlay_pager_new (priv->parent);
927
overlay_pager_show (OVERLAY_PAGER (priv->pager));
952
priv->pager = os_pager_new (priv->parent);
953
os_pager_show (OS_PAGER (priv->pager));
928
954
929
overlay_scrollbar_store_window_position (scrollbar);
955
os_scrollbar_store_window_position (scrollbar);
930
956
931
957
GTK_WIDGET_SET_FLAGS ((scrollbar), GTK_VISIBLE);
932
958
}
933
959
934
960
/* THUMB FUNCTIONS */
935
961
/**
936
* overlay_thumb_button_press_event_cb:
962
* os_thumb_button_press_event_cb:
937
963
* connect to button-press-event
938
964
**/
939
965
static gboolean
940
overlay_thumb_button_press_event_cb (GtkWidget *widget,
966
os_thumb_button_press_event_cb (GtkWidget *widget,
941
967
GdkEventButton *event,
942
968
gpointer user_data)
943
969
{
944
DEBUG
945
970
if (event->type == GDK_BUTTON_PRESS)
946
971
{
947
972
if (event->button == 1)
948
973
{
949
OverlayScrollbar *scrollbar;
950
OverlayScrollbarPrivate *priv;
951
952
scrollbar = OVERLAY_SCROLLBAR (user_data);
953
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (scrollbar));
954
955
/* overlay_scrollbar_map (widget);*/
974
OsScrollbar *scrollbar;
975
OsScrollbarPrivate *priv;
976
977
scrollbar = OS_SCROLLBAR (user_data);
978
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (scrollbar));
979
980
/* os_scrollbar_map (widget);*/
956
981
gtk_window_set_transient_for (GTK_WINDOW (widget), GTK_WINDOW (gtk_widget_get_toplevel (priv->parent)));
957
982
os_present_gdk_window_with_timestamp (priv->parent, event->time);
958
983
981
1006
}
982
1007
983
1008
/**
984
* overlay_thumb_button_release_event_cb:
1009
* os_thumb_button_release_event_cb:
985
1010
* connect to button-release-event
986
1011
**/
987
1012
static gboolean
988
overlay_thumb_button_release_event_cb (GtkWidget *widget,
1013
os_thumb_button_release_event_cb (GtkWidget *widget,
989
1014
GdkEventButton *event,
990
1015
gpointer user_data)
991
1016
{
992
DEBUG
993
1017
if (event->type == GDK_BUTTON_RELEASE)
994
1018
{
995
1019
if (event->button == 1)
996
1020
{
997
OverlayScrollbar *scrollbar;
998
OverlayScrollbarPrivate *priv;
1021
OsScrollbar *scrollbar;
1022
OsScrollbarPrivate *priv;
999
1023
1000
scrollbar = OVERLAY_SCROLLBAR (user_data);
1001
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (scrollbar));
1024
scrollbar = OS_SCROLLBAR (user_data);
1025
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (scrollbar));
1002
1026
1003
1027
gtk_window_set_transient_for (GTK_WINDOW (widget), NULL);
1004
1028
1037
1061
}
1038
1062
1039
1063
/**
1040
* overlay_thumb_enter_notify_event:
1064
* os_thumb_enter_notify_event:
1041
1065
* override class function
1042
1066
**/
1043
1067
static gboolean
1044
overlay_thumb_enter_notify_event_cb (GtkWidget *widget,
1068
os_thumb_enter_notify_event_cb (GtkWidget *widget,
1045
1069
GdkEventCrossing *event,
1046
1070
gpointer user_data)
1047
1071
{
1048
DEBUG
1049
OverlayScrollbar *scrollbar;
1050
OverlayScrollbarPrivate *priv;
1072
OsScrollbar *scrollbar;
1073
OsScrollbarPrivate *priv;
1051
1074
1052
scrollbar = OVERLAY_SCROLLBAR (user_data);
1053
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (scrollbar));
1075
scrollbar = OS_SCROLLBAR (user_data);
1076
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (scrollbar));
1054
1077
1055
1078
priv->enter_notify_event = TRUE;
1056
1079
priv->can_hide = FALSE;
1059
1082
}
1060
1083
1061
1084
/**
1062
* overlay_thumb_leave_notify_event:
1085
* os_thumb_leave_notify_event:
1063
1086
* override class function
1064
1087
**/
1065
1088
static gboolean
1066
overlay_thumb_leave_notify_event_cb (GtkWidget *widget,
1089
os_thumb_leave_notify_event_cb (GtkWidget *widget,
1067
1090
GdkEventCrossing *event,
1068
1091
gpointer user_data)
1069
1092
{
1070
DEBUG
1071
OverlayScrollbar *scrollbar;
1072
OverlayScrollbarPrivate *priv;
1093
OsScrollbar *scrollbar;
1094
OsScrollbarPrivate *priv;
1073
1095
1074
scrollbar = OVERLAY_SCROLLBAR (user_data);
1075
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (scrollbar));
1096
scrollbar = OS_SCROLLBAR (user_data);
1097
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (scrollbar));
1076
1098
1077
1099
if (!priv->button_press_event)
1078
1100
priv->can_hide = TRUE;
1079
1101
1080
g_timeout_add (TIMEOUT_HIDE, overlay_scrollbar_hide_thumb, scrollbar);
1102
g_timeout_add (TIMEOUT_HIDE, os_scrollbar_hide_thumb, scrollbar);
1081
1103
1082
1104
return TRUE;
1083
1105
}
1084
1106
1085
1107
/**
1086
* overlay_thumb_motion_notify_event:
1108
* os_thumb_motion_notify_event:
1087
1109
* override class function
1088
1110
**/
1089
1111
static gboolean
1090
overlay_thumb_motion_notify_event_cb (GtkWidget *widget,
1112
os_thumb_motion_notify_event_cb (GtkWidget *widget,
1091
1113
GdkEventMotion *event,
1092
1114
gpointer user_data)
1093
1115
{
1094
DEBUG
1095
OverlayScrollbar *scrollbar;
1096
OverlayScrollbarPrivate *priv;
1116
OsScrollbar *scrollbar;
1117
OsScrollbarPrivate *priv;
1097
1118
1098
scrollbar = OVERLAY_SCROLLBAR (user_data);
1099
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (scrollbar));
1119
scrollbar = OS_SCROLLBAR (user_data);
1120
priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (scrollbar));
1100
1121
1101
1122
/* XXX improve speed by not rendering when moving */
1102
1123
if (priv->button_press_event)
1117
1138
priv->slide_initial_coordinate = event->x_root;
1118
1139
}
1119
1140
1120
overlay_scrollbar_move (scrollbar, event->x_root, event->y_root);
1141
os_scrollbar_move (scrollbar, event->x_root, event->y_root);
1121
1142
priv->value_changed_event = FALSE;
1122
1143
}
1123
1144
1126
1147
1127
1148
priv->motion_notify_event = TRUE;
1128
1149
1129
overlay_scrollbar_move (scrollbar, event->x_root, event->y_root);
1150
os_scrollbar_move (scrollbar, event->x_root, event->y_root);
1130
1151
1131
1152
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
1132
1153
{
1172
1193
/* OVERLAY FUNCTIONS */
1173
1194
/**
1174
1195
* overlay_move:
1175
* move the overlay_pager to the right position
1196
* move the os_pager to the right position
1176
1197
**/
1177
1198
static void
1178
overlay_move (OverlayScrollbar *scrollbar)
1199
overlay_move (OsScrollbar *scrollbar)
1179
1200
{
1180
DEBUG
1181
1201
GdkRectangle mask;
1182
OverlayScrollbarPrivate *priv;
1202
OsScrollbarPrivate *priv;
1183
1203
1184
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
1204
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
1185
1205
1186
1206
mask.x = 0;
1187
1207
mask.y = priv->overlay.y;
1189
1209
mask.height = priv->overlay.height;
1190
1210
1191
1211
if (priv->overlay.height >= priv->overlay_all.height - 2)
1192
overlay_pager_hide (OVERLAY_PAGER (priv->pager));
1212
os_pager_hide (OS_PAGER (priv->pager));
1193
1213
else if (priv->proximity)
1194
overlay_pager_show (OVERLAY_PAGER (priv->pager));
1214
os_pager_show (OS_PAGER (priv->pager));
1195
1215
1196
overlay_pager_move_resize (OVERLAY_PAGER (priv->pager), mask);
1216
os_pager_move_resize (OS_PAGER (priv->pager), mask);
1197
1217
}
1198
1218
1199
1219
/**
1201
1221
* resize the overlay window
1202
1222
**/
1203
1223
static void
1204
overlay_resize_window (OverlayScrollbar *scrollbar)
1224
overlay_resize_window (OsScrollbar *scrollbar)
1205
1225
{
1206
DEBUG
1207
1226
GdkRectangle rect;
1208
OverlayScrollbarPrivate *priv;
1227
OsScrollbarPrivate *priv;
1209
1228
1210
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
1229
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
1211
1230
1212
1231
rect.x = priv->overlay_all.x;
1213
1232
rect.y = priv->overlay_all.y + 1;
1214
1233
rect.width = 3;
1215
1234
rect.height = priv->overlay_all.height - 2;
1216
1235
1217
overlay_pager_size_allocate (OVERLAY_PAGER (priv->pager), rect);
1236
os_pager_size_allocate (OS_PAGER (priv->pager), rect);
1218
1237
}
1219
1238
1220
1239
/* ADJUSTMENT FUNCTIONS */
1226
1245
adjustment_value_changed_cb (GtkAdjustment *adjustment,
1227
1246
gpointer user_data)
1228
1247
{
1229
DEBUG
1230
OverlayScrollbar *scrollbar;
1231
OverlayScrollbarPrivate *priv;
1232
1233
scrollbar = OVERLAY_SCROLLBAR (user_data);
1234
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
1235
1236
overlay_scrollbar_calc_layout_pager (scrollbar, adjustment->value);
1237
overlay_scrollbar_calc_layout_slider (scrollbar, adjustment->value);
1248
OsScrollbar *scrollbar;
1249
OsScrollbarPrivate *priv;
1250
1251
scrollbar = OS_SCROLLBAR (user_data);
1252
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
1253
1254
os_scrollbar_calc_layout_pager (scrollbar, adjustment->value);
1255
os_scrollbar_calc_layout_slider (scrollbar, adjustment->value);
1238
1256
1239
1257
if (!priv->motion_notify_event && !priv->enter_notify_event)
1240
1258
gtk_widget_hide (GTK_WIDGET (priv->thumb));
1252
1270
/* gpointer user_data)*/
1253
1271
/*{*/
1254
1272
/* printf("%s()\n", __func__);*/
1255
/* OverlayScrollbarPrivate *priv;*/
1273
/* OsScrollbarPrivate *priv;*/
1256
1274
1257
/* priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (user_data));*/
1275
/* priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (user_data));*/
1258
1276
1259
1277
/* if (GDK_IS_WINDOW (gtk_widget_get_window (widget)))*/
1260
1278
/* {*/
1264
1282
1265
1283
/* if (priv->pager != NULL)*/
1266
1284
/* {*/
1267
/* printf ("-> overlay_pager_hide\n");*/
1268
/* overlay_pager_hide (OVERLAY_PAGER (priv->pager));*/
1285
/* printf ("-> os_pager_hide\n");*/
1286
/* os_pager_hide (OS_PAGER (priv->pager));*/
1269
1287
/* }*/
1270
1288
/*}*/
1271
1289
1278
1296
/* gpointer user_data)*/
1279
1297
/*{*/
1280
1298
/* printf("%s()\n", __func__);*/
1281
/* OverlayScrollbarPrivate *priv;*/
1299
/* OsScrollbarPrivate *priv;*/
1282
1300
1283
/* priv = OVERLAY_SCROLLBAR_GET_PRIVATE (OVERLAY_SCROLLBAR (user_data));*/
1301
/* priv = OS_SCROLLBAR_GET_PRIVATE (OS_SCROLLBAR (user_data));*/
1284
1302
1285
1303
/* if (GDK_IS_WINDOW (gtk_widget_get_parent_window (widget)))*/
1286
1304
/* {*/
1292
1310
1293
1311
/* if (priv->pager != NULL)*/
1294
1312
/* {*/
1295
/* printf ("-> overlay_pager_show\n");*/
1296
/* overlay_pager_show (OVERLAY_PAGER (priv->pager));*/
1313
/* printf ("-> os_pager_show\n");*/
1314
/* os_pager_show (OS_PAGER (priv->pager));*/
1297
1315
/* }*/
1298
1316
/*}*/
1299
1317
1306
1324
GdkEventExpose *event,
1307
1325
gpointer user_data)
1308
1326
{
1309
DEBUG
1310
OverlayScrollbar *scrollbar;
1311
OverlayScrollbarPrivate *priv;
1327
OsScrollbar *scrollbar;
1328
OsScrollbarPrivate *priv;
1312
1329
1313
scrollbar = OVERLAY_SCROLLBAR (user_data);
1314
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
1330
scrollbar = OS_SCROLLBAR (user_data);
1331
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
1315
1332
1316
1333
if (!priv->toplevel_connected)
1317
1334
{
1318
overlay_scrollbar_toplevel_connect (scrollbar);
1335
os_scrollbar_toplevel_connect (scrollbar);
1319
1336
}
1320
1337
1321
1338
return FALSE;
1330
1347
GtkAllocation *allocation,
1331
1348
gpointer user_data)
1332
1349
{
1333
DEBUG
1334
OverlayScrollbar *scrollbar;
1335
OverlayScrollbarPrivate *priv;
1336
1337
scrollbar = OVERLAY_SCROLLBAR (user_data);
1338
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
1339
1340
priv->slider.width = OVERLAY_SCROLLBAR_WIDTH;
1341
priv->slider.height = OVERLAY_SCROLLBAR_HEIGHT;
1350
OsScrollbar *scrollbar;
1351
OsScrollbarPrivate *priv;
1352
1353
scrollbar = OS_SCROLLBAR (user_data);
1354
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
1355
1356
priv->slider.width = OS_SCROLLBAR_WIDTH;
1357
priv->slider.height = OS_SCROLLBAR_HEIGHT;
1342
1358
1343
1359
priv->trough.x = 0;
1344
1360
priv->trough.y = 0;
1352
1368
priv->thumb_all.x = allocation->x + allocation->width;
1353
1369
1354
1370
if (priv->adjustment != NULL)
1355
overlay_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
1371
os_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
1356
1372
1357
1373
if (priv->pager != NULL)
1358
1374
overlay_resize_window (scrollbar);
1359
1375
1360
overlay_scrollbar_store_window_position (scrollbar);
1376
os_scrollbar_store_window_position (scrollbar);
1361
1377
}
1362
1378
1363
1379
/* TOPLEVEL FUNCTIONS */
1370
1386
GdkEventConfigure *event,
1371
1387
gpointer user_data)
1372
1388
{
1373
DEBUG
1374
OverlayScrollbar *scrollbar;
1375
OverlayScrollbarPrivate *priv;
1389
OsScrollbar *scrollbar;
1390
OsScrollbarPrivate *priv;
1376
1391
1377
scrollbar = OVERLAY_SCROLLBAR (user_data);
1378
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
1392
scrollbar = OS_SCROLLBAR (user_data);
1393
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
1379
1394
1380
1395
gtk_widget_hide (GTK_WIDGET (priv->thumb));
1381
1396
1382
overlay_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
1383
overlay_scrollbar_calc_layout_slider (scrollbar, priv->adjustment->value);
1397
os_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
1398
os_scrollbar_calc_layout_slider (scrollbar, priv->adjustment->value);
1384
1399
gtk_window_move (GTK_WINDOW (priv->thumb),
1385
1400
event->x + priv->thumb_all.x + priv->slider.x,
1386
1401
event->y + priv->thumb_all.y + priv->slider.y);
1387
1402
1388
overlay_scrollbar_store_window_position (scrollbar);
1403
os_scrollbar_store_window_position (scrollbar);
1389
1404
1390
1405
overlay_resize_window (scrollbar);
1391
1406
overlay_move (scrollbar);
1402
1417
GdkEvent *event,
1403
1418
gpointer user_data)
1404
1419
{
1405
DEBUG
1406
1420
1407
OverlayScrollbar *scrollbar;
1408
OverlayScrollbarPrivate *priv;
1421
OsScrollbar *scrollbar;
1422
OsScrollbarPrivate *priv;
1409
1423
XEvent *xevent;
1410
1424
1411
scrollbar = OVERLAY_SCROLLBAR (user_data);
1412
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
1425
scrollbar = OS_SCROLLBAR (user_data);
1426
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
1413
1427
xevent = gdkxevent;
1414
1428
1415
1429
g_return_val_if_fail (priv->pager != NULL, GDK_FILTER_CONTINUE);
1416
1430
g_return_val_if_fail (priv->thumb != NULL, GDK_FILTER_CONTINUE);
1417
1431
1418
overlay_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
1419
overlay_scrollbar_calc_layout_slider (scrollbar, priv->adjustment->value);
1432
os_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
1433
os_scrollbar_calc_layout_slider (scrollbar, priv->adjustment->value);
1420
1434
1421
1435
if (priv->proximity)
1422
1436
{
1451
1465
}
1452
1466
1453
1467
gtk_widget_show (GTK_WIDGET (priv->thumb));
1454
/* overlay_scrollbar_map (GTK_WIDGET (scrollbar));*/
1468
/* os_scrollbar_map (GTK_WIDGET (scrollbar));*/
1455
1469
}
1456
1470
else
1457
1471
{
1458
1472
priv->can_hide = TRUE;
1459
overlay_scrollbar_hide_thumb (scrollbar);
1473
os_scrollbar_hide_thumb (scrollbar);
1460
1474
}
1461
1475
}
1462
1476
}
1463
1477
else
1464
1478
{
1465
overlay_pager_hide (OVERLAY_PAGER (priv->pager));
1479
os_pager_hide (OS_PAGER (priv->pager));
1466
1480
}
1467
1481
1468
1482
/* code to check if the window is active */
1478
1492
if (active_window != gtk_widget_get_window (priv->parent))
1479
1493
{
1480
1494
gtk_widget_hide (GTK_WIDGET (priv->thumb));
1481
overlay_pager_set_active (OVERLAY_PAGER (priv->pager), FALSE);
1495
os_pager_set_active (OS_PAGER (priv->pager), FALSE);
1482
1496
}
1483
1497
else
1484
overlay_pager_set_active (OVERLAY_PAGER (priv->pager), TRUE);
1498
os_pager_set_active (OS_PAGER (priv->pager), TRUE);
1485
1499
}
1486
1500
1487
1501
return GDK_FILTER_CONTINUE;
1489
1503
1490
1504
/**
1491
1505
* toplevel_leave_notify_event_cb:
1492
* hide the OverlayScrollbar, when the pointer leaves the toplevel GtkWindow
1506
* hide the OsScrollbar, when the pointer leaves the toplevel GtkWindow
1493
1507
**/
1494
1508
static gboolean
1495
1509
toplevel_leave_notify_event_cb (GtkWidget *widget,
1496
1510
GdkEventCrossing *event,
1497
1511
gpointer user_data)
1498
1512
{
1499
DEBUG
1500
OverlayScrollbar *scrollbar;
1501
OverlayScrollbarPrivate *priv;
1502
1503
scrollbar = OVERLAY_SCROLLBAR (user_data);
1504
priv = OVERLAY_SCROLLBAR_GET_PRIVATE (scrollbar);
1505
1506
g_timeout_add (TIMEOUT_HIDE, overlay_scrollbar_hide_thumb, scrollbar);
1513
OsScrollbar *scrollbar;
1514
OsScrollbarPrivate *priv;
1515
1516
scrollbar = OS_SCROLLBAR (user_data);
1517
priv = OS_SCROLLBAR_GET_PRIVATE (scrollbar);
1518
1519
g_timeout_add (TIMEOUT_HIDE, os_scrollbar_hide_thumb, scrollbar);
1507
1520
1508
1521
return FALSE;
1509
1522
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1