← Back to branch summary

~ubuntu-branches/ubuntu/vivid/gtk-vnc/vivid-proposed

« back to all changes in this revision

Viewing changes to src/vncdisplay.c

  • Committer: Package Import Robot
  • Author(s): Laurent Léonard
  • Date: 2012-07-24 00:49:55 UTC
  • mfrom: (1.2.5)
  • Revision ID: package-import@ubuntu.com-20120724004955-6711f7ontxvn9yzy
Tags: 0.5.1-1
* [e2591bf] Imported Upstream version 0.5.1
* [a0f6408] Drop patch
  - Allow-Unix-domain-sockets-in-gvncviewer.patch - fixed upstream
* [c031b94] Bump Standards-Version to 3.9.3
* [61e5796] Set build directories for dh_auto_clean
* [7fde78d] Drop patch
  - Look-for-generated-enums-in-srcdir.patch
* [fada5be] Add dh_auto_test override
* [d7567f1] Update symbols
* [6189676] Enable dpkg-buildflags

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/vncdisplay.c
143
143
#define GtkObject GtkWidget
144
144
#define GtkObjectClass GtkWidgetClass
145
145
#define GTK_OBJECT_CLASS(c) GTK_WIDGET_CLASS(c)
146
 
 
 
146
#define gdk_cursor_unref(c) g_object_unref(c)
147
147
#endif
148
148
 
 
149
 
149
150
static guint signals[LAST_SIGNAL] = { 0, 0, 0, 0,
150
151
                                      0, 0, 0, 0,
151
152
                                      0, 0, 0, 0, 0,};
395
396
}
396
397
#endif
397
398
 
398
 
static void do_keyboard_grab(VncDisplay *obj, gboolean quiet)
 
399
#if !GTK_CHECK_VERSION(3, 0, 0)
 
400
static void do_keyboard_grab_all(GdkWindow *window)
399
401
{
400
 
    VncDisplayPrivate *priv = obj->priv;
401
 
 
402
 
    gdk_keyboard_grab(gtk_widget_get_window(GTK_WIDGET(obj)),
 
402
    gdk_keyboard_grab(window,
403
403
                      FALSE,
404
404
                      GDK_CURRENT_TIME);
 
405
}
 
406
static void do_keyboard_ungrab_all(GdkWindow *window G_GNUC_UNUSED)
 
407
{
 
408
    gdk_keyboard_ungrab(GDK_CURRENT_TIME);
 
409
}
 
410
static void do_pointer_grab_all(GdkWindow *window,
 
411
                                GdkCursor *cursor)
 
412
{
 
413
    gdk_pointer_grab(window,
 
414
                     FALSE, /* All events to come to our window directly */
 
415
                     GDK_POINTER_MOTION_MASK |
 
416
                     GDK_BUTTON_PRESS_MASK |
 
417
                     GDK_BUTTON_RELEASE_MASK |
 
418
                     GDK_BUTTON_MOTION_MASK |
 
419
                     GDK_SCROLL_MASK,
 
420
                     NULL, /* Allow cursor to move over entire desktop */
 
421
                     cursor,
 
422
                     GDK_CURRENT_TIME);
 
423
}
 
424
static void do_pointer_ungrab_all(GdkWindow *window G_GNUC_UNUSED)
 
425
{
 
426
    gdk_pointer_ungrab(GDK_CURRENT_TIME);
 
427
}
 
428
#else
 
429
static void do_keyboard_grab_all(GdkWindow *window)
 
430
{
 
431
    GdkDeviceManager *mgr = gdk_display_get_device_manager(gdk_window_get_display(window));
 
432
    GList *devices = gdk_device_manager_list_devices(mgr, GDK_DEVICE_TYPE_MASTER);
 
433
    GList *tmp = devices;
 
434
    while (tmp) {
 
435
        GdkDevice *dev = tmp->data;
 
436
        if (gdk_device_get_source(dev) == GDK_SOURCE_KEYBOARD)
 
437
            gdk_device_grab(dev,
 
438
                            window,
 
439
                            GDK_OWNERSHIP_NONE,
 
440
                            FALSE,
 
441
                            GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
 
442
                            NULL,
 
443
                            GDK_CURRENT_TIME);
 
444
        tmp = tmp->next;
 
445
    }
 
446
    g_list_free(devices);
 
447
}
 
448
 
 
449
static void do_keyboard_ungrab_all(GdkWindow *window)
 
450
{
 
451
    GdkDeviceManager *mgr = gdk_display_get_device_manager(gdk_window_get_display(window));
 
452
    GList *devices = gdk_device_manager_list_devices(mgr, GDK_DEVICE_TYPE_MASTER);
 
453
    GList *tmp = devices;
 
454
    while (tmp) {
 
455
        GdkDevice *dev = tmp->data;
 
456
        if (gdk_device_get_source(dev) == GDK_SOURCE_KEYBOARD)
 
457
            gdk_device_ungrab(dev,
 
458
                              GDK_CURRENT_TIME);
 
459
        tmp = tmp->next;
 
460
    }
 
461
    g_list_free(devices);
 
462
}
 
463
 
 
464
static void do_pointer_grab_all(GdkWindow *window,
 
465
                                GdkCursor *cursor)
 
466
{
 
467
    GdkDeviceManager *mgr = gdk_display_get_device_manager(gdk_window_get_display(window));
 
468
    GList *devices = gdk_device_manager_list_devices(mgr, GDK_DEVICE_TYPE_MASTER);
 
469
    GList *tmp = devices;
 
470
    while (tmp) {
 
471
        GdkDevice *dev = tmp->data;
 
472
        if (gdk_device_get_source(dev) == GDK_SOURCE_MOUSE)
 
473
            gdk_device_grab(dev,
 
474
                            window,
 
475
                            GDK_OWNERSHIP_NONE,
 
476
                            FALSE, /* All events to come to our window directly */
 
477
                            GDK_POINTER_MOTION_MASK |
 
478
                            GDK_BUTTON_PRESS_MASK |
 
479
                            GDK_BUTTON_RELEASE_MASK |
 
480
                            GDK_BUTTON_MOTION_MASK |
 
481
                            GDK_SCROLL_MASK,
 
482
                            cursor,
 
483
                            GDK_CURRENT_TIME);
 
484
        tmp = tmp->next;
 
485
    }
 
486
    g_list_free(devices);
 
487
}
 
488
 
 
489
static void do_pointer_ungrab_all(GdkWindow *window)
 
490
{
 
491
    GdkDeviceManager *mgr = gdk_display_get_device_manager(gdk_window_get_display(window));
 
492
    GList *devices = gdk_device_manager_list_devices(mgr, GDK_DEVICE_TYPE_MASTER);
 
493
    GList *tmp = devices;
 
494
    while (tmp) {
 
495
        GdkDevice *dev = tmp->data;
 
496
        if (gdk_device_get_source(dev) == GDK_SOURCE_MOUSE)
 
497
            gdk_device_ungrab(dev,
 
498
                              GDK_CURRENT_TIME);
 
499
        tmp = tmp->next;
 
500
    }
 
501
    g_list_free(devices);
 
502
}
 
503
#endif
 
504
 
 
505
static void do_keyboard_grab(VncDisplay *obj, gboolean quiet)
 
506
{
 
507
    VncDisplayPrivate *priv = obj->priv;
 
508
 
 
509
    do_keyboard_grab_all(gtk_widget_get_window(GTK_WIDGET(obj)));
405
510
    priv->in_keyboard_grab = TRUE;
406
511
    if (!quiet)
407
512
        g_signal_emit(obj, signals[VNC_KEYBOARD_GRAB], 0);
412
517
{
413
518
    VncDisplayPrivate *priv = obj->priv;
414
519
 
415
 
    gdk_keyboard_ungrab(GDK_CURRENT_TIME);
 
520
    do_keyboard_ungrab_all(gtk_widget_get_window(GTK_WIDGET(obj)));
416
521
    priv->in_keyboard_grab = FALSE;
417
522
    if (!quiet)
418
523
        g_signal_emit(obj, signals[VNC_KEYBOARD_UNGRAB], 0);
448
553
     * what window the pointer is actally over, so use 'FALSE' for
449
554
     * 'owner_events' parameter
450
555
     */
451
 
    gdk_pointer_grab(gtk_widget_get_window(GTK_WIDGET(obj)),
452
 
                     FALSE, /* All events to come to our window directly */
453
 
                     GDK_POINTER_MOTION_MASK |
454
 
                     GDK_BUTTON_PRESS_MASK |
455
 
                     GDK_BUTTON_RELEASE_MASK |
456
 
                     GDK_BUTTON_MOTION_MASK |
457
 
                     GDK_SCROLL_MASK,
458
 
                     NULL, /* Allow cursor to move over entire desktop */
459
 
                     priv->remote_cursor ? priv->remote_cursor : priv->null_cursor,
460
 
                     GDK_CURRENT_TIME);
 
556
    do_pointer_grab_all(gtk_widget_get_window(GTK_WIDGET(obj)),
 
557
                        priv->remote_cursor ? priv->remote_cursor : priv->null_cursor);
461
558
    priv->in_pointer_grab = TRUE;
462
559
    if (!quiet)
463
560
        g_signal_emit(obj, signals[VNC_POINTER_GRAB], 0);
471
568
    if (!priv->grab_keyboard)
472
569
        do_keyboard_ungrab(obj, quiet);
473
570
 
474
 
    gdk_pointer_ungrab(GDK_CURRENT_TIME);
 
571
    do_pointer_ungrab_all(gtk_widget_get_window(GTK_WIDGET(obj)));
475
572
    priv->in_pointer_grab = FALSE;
476
573
 
477
574
    if (priv->absolute)
629
726
 
630
727
    /* Next adjust the real client pointer */
631
728
    if (!priv->absolute) {
632
 
        GdkDisplay *display = gtk_widget_get_display(widget);
633
729
        GdkScreen *screen = gtk_widget_get_screen(widget);
634
730
        int x = (int)motion->x_root;
635
731
        int y = (int)motion->y_root;
647
743
        if (y >= (gdk_screen_get_height(screen) - 1)) y -= 200;
648
744
 
649
745
        if (x != (int)motion->x_root || y != (int)motion->y_root) {
 
746
#if GTK_CHECK_VERSION(3, 0, 0)
 
747
            GdkDevice *dev = gdk_event_get_device((GdkEvent*)motion);
 
748
            gdk_device_warp(dev, screen, x, y);
 
749
#else
 
750
            GdkDisplay *display = gtk_widget_get_display(widget);
650
751
            gdk_display_warp_pointer(display, screen, x, y);
 
752
#endif
651
753
            priv->last_x = -1;
652
754
            priv->last_y = -1;
653
755
            return FALSE;
1423
1525
    return TRUE;
1424
1526
}
1425
1527
 
 
1528
 
 
1529
gboolean vnc_display_open_fd_with_hostname(VncDisplay *obj, int fd, const char *hostname)
 
1530
{
 
1531
    VncDisplayPrivate *priv = obj->priv;
 
1532
 
 
1533
    if (vnc_connection_is_open(priv->conn))
 
1534
        return FALSE;
 
1535
 
 
1536
    if (!vnc_connection_set_shared(priv->conn, priv->shared_flag))
 
1537
        return FALSE;
 
1538
 
 
1539
    if (!vnc_connection_open_fd_with_hostname(priv->conn, fd, hostname))
 
1540
        return FALSE;
 
1541
 
 
1542
    g_object_ref(G_OBJECT(obj));
 
1543
 
 
1544
    return TRUE;
 
1545
}
 
1546
 
 
1547
 
 
1548
gboolean vnc_display_open_addr(VncDisplay *obj, GSocketAddress *addr, const char *hostname)
 
1549
{
 
1550
    VncDisplayPrivate *priv = obj->priv;
 
1551
 
 
1552
    if (vnc_connection_is_open(priv->conn))
 
1553
        return FALSE;
 
1554
 
 
1555
    if (!vnc_connection_set_shared(priv->conn, priv->shared_flag))
 
1556
        return FALSE;
 
1557
 
 
1558
    if (!vnc_connection_open_addr(priv->conn, addr, hostname))
 
1559
        return FALSE;
 
1560
 
 
1561
    g_object_ref(G_OBJECT(obj));
 
1562
 
 
1563
    return TRUE;
 
1564
}
 
1565
 
 
1566
 
1426
1567
gboolean vnc_display_open_host(VncDisplay *obj, const char *host, const char *port)
1427
1568
{
1428
1569
    VncDisplayPrivate *priv = obj->priv;
2061
2202
        do_pointer_ungrab(obj, FALSE);
2062
2203
}
2063
2204
 
 
2205
 
 
2206
/**
 
2207
 * vnc_display_set_grab_keys:
 
2208
 * @obj: (transfer none): the vnc display object
 
2209
 * @seq: (transfer none): the new grab sequence
 
2210
 *
 
2211
 * Set the key grab sequence
 
2212
 */
2064
2213
void vnc_display_set_grab_keys(VncDisplay *obj, VncGrabSequence *seq)
2065
2214
{
2066
2215
    if (obj->priv->vncgrabseq) {
2072
2221
    else
2073
2222
        obj->priv->vncgrabseq = vnc_grab_sequence_new_from_string("Control_L+Alt_L");
2074
2223
    obj->priv->vncactiveseq = g_new0(gboolean, obj->priv->vncgrabseq->nkeysyms);
 
2224
    if (G_UNLIKELY(vnc_util_get_debug())) {
 
2225
        gchar *str = vnc_grab_sequence_as_string(obj->priv->vncgrabseq);
 
2226
        VNC_DEBUG("Grab sequence is now %s", str);
 
2227
        g_free(str);
 
2228
    }
2075
2229
}
2076
2230
 
 
2231
 
 
2232
/**
 
2233
 * vnc_display_get_grab_keys:
 
2234
 * @obj: the vnc display object
 
2235
 *
 
2236
 * Get the current grab key sequence
 
2237
 *
 
2238
 * Returns: (transfer none): the current grab keys
 
2239
 */
2077
2240
VncGrabSequence *vnc_display_get_grab_keys(VncDisplay *obj)
2078
2241
{
2079
2242
    return obj->priv->vncgrabseq;
2124
2287
 * Take a screenshot of the display.
2125
2288
 *
2126
2289
 * Returns: (transfer full): a #GdkPixbuf with the screenshot image buffer
2127
 
 **/
 
2290
 */
2128
2291
GdkPixbuf *vnc_display_get_pixbuf(VncDisplay *obj)
2129
2292
{
2130
2293
    VncDisplayPrivate *priv = obj->priv;