← Back to branch summary

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

« back to all changes in this revision

Viewing changes to .pc/Allow-Unix-domain-sockets-in-gvncviewer.patch/examples/gvncviewer.c

  • Committer: Package Import Robot
  • Author(s): Guido Günther
  • Date: 2012-01-28 20:16:42 UTC
  • Revision ID: package-import@ubuntu.com-20120128201642-syuzp2g5w9ltvcu0
Tags: 0.5.0-3
http://bugs.debian.org/654849
http://bugs.debian.org/655460
* [0d2d0ae] Build-Conflict on valac-0.12.
  Thanks to Daniel Kahn Gillmor for the testing (Closes: #654849)
* [b12be0b] Allow Unix domain sockets in gvncviewer.
  Thanks to Daniel Kahn Gillmor for the patch (Closes: #655460)

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/Allow-Unix-domain-sockets-in-gvncviewer.patch/examples/gvncviewer.c
 
1
/*
 
2
 * GTK VNC Widget
 
3
 *
 
4
 * Copyright (C) 2006  Anthony Liguori <anthony@codemonkey.ws>
 
5
 *
 
6
 * This library is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU Lesser General Public
 
8
 * License as published by the Free Software Foundation; either
 
9
 * version 2.0 of the License, or (at your option) any later version.
 
10
 *
 
11
 * This library is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 * Lesser General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU Lesser General Public
 
17
 * License along with this library; if not, write to the Free Software
 
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 
19
 */
 
20
 
 
21
#include <config.h>
 
22
 
 
23
#include <vncdisplay.h>
 
24
#include <vncutil.h>
 
25
#ifdef HAVE_PULSEAUDIO
 
26
#include <vncaudiopulse.h>
 
27
#endif
 
28
#include <gtk/gtk.h>
 
29
#include <gdk/gdkkeysyms.h>
 
30
#include <stdlib.h>
 
31
#include <string.h>
 
32
#include <glib.h>
 
33
 
 
34
#if WITH_LIBVIEW
 
35
#include <libview/autoDrawer.h>
 
36
#endif
 
37
 
 
38
#ifndef GDK_Return
 
39
#define GDK_Return GDK_KEY_Return
 
40
#endif
 
41
#ifndef GDK_Escape
 
42
#define GDK_Escape GDK_KEY_Escape
 
43
#endif
 
44
#ifndef GDK_BackSpace
 
45
#define GDK_BackSpace GDK_KEY_BackSpace
 
46
#endif
 
47
#ifndef GDK_Delete
 
48
#define GDK_Delete GDK_KEY_Delete
 
49
#endif
 
50
#ifndef GDK_Control_L
 
51
#define GDK_Control_L GDK_KEY_Control_L
 
52
#endif
 
53
#ifndef GDK_Alt_L
 
54
#define GDK_Alt_L GDK_KEY_Alt_L
 
55
#endif
 
56
#ifndef GDK_F1
 
57
#define GDK_F1 GDK_KEY_F1
 
58
#endif
 
59
#ifndef GDK_F2
 
60
#define GDK_F2 GDK_KEY_F2
 
61
#endif
 
62
#ifndef GDK_F3
 
63
#define GDK_F3 GDK_KEY_F3
 
64
#endif
 
65
#ifndef GDK_F4
 
66
#define GDK_F4 GDK_KEY_F4
 
67
#endif
 
68
#ifndef GDK_F5
 
69
#define GDK_F5 GDK_KEY_F5
 
70
#endif
 
71
#ifndef GDK_F6
 
72
#define GDK_F6 GDK_KEY_F6
 
73
#endif
 
74
#ifndef GDK_F7
 
75
#define GDK_F7 GDK_KEY_F7
 
76
#endif
 
77
#ifndef GDK_F8
 
78
#define GDK_F8 GDK_KEY_F8
 
79
#endif
 
80
#ifndef GDK_F11
 
81
#define GDK_F11 GDK_KEY_F11
 
82
#endif
 
83
 
 
84
 
 
85
static gchar **args = NULL;
 
86
static const GOptionEntry options [] =
 
87
    {
 
88
        {
 
89
            G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_STRING_ARRAY, &args,
 
90
            NULL, "[hostname][:display]" },
 
91
        { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, 0 }
 
92
    };
 
93
 
 
94
#ifdef HAVE_PULSEAUDIO
 
95
static VncAudioPulse *pa = NULL;
 
96
#endif
 
97
 
 
98
static GtkWidget *vnc;
 
99
 
 
100
typedef struct {
 
101
    GtkWidget *label;
 
102
    guint curkeys;
 
103
    guint numkeys;
 
104
    guint *keysyms;
 
105
    gboolean set;
 
106
} VncGrabDefs;
 
107
 
 
108
static void set_title(VncDisplay *vncdisplay, GtkWidget *window,
 
109
                      gboolean grabbed)
 
110
{
 
111
    const gchar *name = vnc_display_get_name(VNC_DISPLAY(vncdisplay));
 
112
    VncGrabSequence *seq = vnc_display_get_grab_keys(vncdisplay);
 
113
    gchar *seqstr = vnc_grab_sequence_as_string(seq);
 
114
    gchar *title;
 
115
 
 
116
    if (grabbed)
 
117
        title = g_strdup_printf("(Press %s to release pointer) %s - GVncViewer",
 
118
                                seqstr, name);
 
119
    else
 
120
        title = g_strdup_printf("%s - GVncViewer",
 
121
                                name);
 
122
 
 
123
    gtk_window_set_title(GTK_WINDOW(window), title);
 
124
 
 
125
    g_free(seqstr);
 
126
    g_free(title);
 
127
}
 
128
 
 
129
static gboolean vnc_screenshot(GtkWidget *window G_GNUC_UNUSED,
 
130
                               GdkEvent *ev, GtkWidget *vncdisplay)
 
131
{
 
132
    if (ev->key.keyval == GDK_F11) {
 
133
        GdkPixbuf *pix = vnc_display_get_pixbuf(VNC_DISPLAY(vncdisplay));
 
134
        gdk_pixbuf_save(pix, "gvncviewer.png", "png", NULL, "tEXt::Generator App", "gvncviewer", NULL);
 
135
        g_object_unref(pix);
 
136
        printf("Screenshot saved to gvncviewer.png\n");
 
137
    }
 
138
    return FALSE;
 
139
}
 
140
 
 
141
static void vnc_grab(GtkWidget *vncdisplay, GtkWidget *window)
 
142
{
 
143
    set_title(VNC_DISPLAY(vncdisplay), window, TRUE);
 
144
}
 
145
 
 
146
static void vnc_ungrab(GtkWidget *vncdisplay, GtkWidget *window)
 
147
{
 
148
    set_title(VNC_DISPLAY(vncdisplay), window, FALSE);
 
149
}
 
150
 
 
151
static int connected = 0;
 
152
 
 
153
static void vnc_connected(GtkWidget *vncdisplay G_GNUC_UNUSED)
 
154
{
 
155
    printf("Connected to server\n");
 
156
    connected = 1;
 
157
}
 
158
 
 
159
static void vnc_initialized(GtkWidget *vncdisplay, GtkWidget *window)
 
160
{
 
161
    printf("Connection initialized\n");
 
162
    set_title(VNC_DISPLAY(vncdisplay), window, FALSE);
 
163
    gtk_widget_show_all(window);
 
164
 
 
165
#ifdef HAVE_PULSEAUDIO
 
166
    VncConnection *conn;
 
167
    VncAudioFormat format = {
 
168
        VNC_AUDIO_FORMAT_RAW_S32,
 
169
        2,
 
170
        44100,
 
171
    };
 
172
    conn = vnc_display_get_connection(VNC_DISPLAY(vncdisplay));
 
173
    vnc_connection_set_audio_format(conn, &format);
 
174
    vnc_connection_set_audio(conn, VNC_AUDIO(pa));
 
175
    vnc_connection_audio_enable(conn);
 
176
#endif
 
177
}
 
178
 
 
179
static void vnc_auth_failure(GtkWidget *vncdisplay G_GNUC_UNUSED,
 
180
                             const char *msg)
 
181
{
 
182
    printf("Authentication failed '%s'\n", msg ? msg : "");
 
183
}
 
184
 
 
185
static void vnc_desktop_resize(GtkWidget *vncdisplay G_GNUC_UNUSED,
 
186
                               int width, int height)
 
187
{
 
188
    printf("Remote desktop size changed to %dx%d\n", width, height);
 
189
}
 
190
 
 
191
static void vnc_disconnected(GtkWidget *vncdisplay G_GNUC_UNUSED)
 
192
{
 
193
    if(connected)
 
194
        printf("Disconnected from server\n");
 
195
    else
 
196
        printf("Failed to connect to server\n");
 
197
    gtk_main_quit();
 
198
}
 
199
 
 
200
static void send_caf1(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
 
201
{
 
202
    guint keys[] = { GDK_Control_L, GDK_Alt_L, GDK_F1 };
 
203
    printf("Sending Ctrl+Alt+F1\n");
 
204
    vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
 
205
                          sizeof(keys)/sizeof(keys[0]));
 
206
}
 
207
 
 
208
static void send_caf2(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
 
209
{
 
210
    guint keys[] = { GDK_Control_L, GDK_Alt_L, GDK_F2 };
 
211
    printf("Sending Ctrl+Alt+F2\n");
 
212
    vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
 
213
                          sizeof(keys)/sizeof(keys[0]));
 
214
}
 
215
 
 
216
static void send_caf3(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
 
217
{
 
218
    guint keys[] = { GDK_Control_L, GDK_Alt_L, GDK_F3 };
 
219
    printf("Sending Ctrl+Alt+F3\n");
 
220
    vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
 
221
                          sizeof(keys)/sizeof(keys[0]));
 
222
}
 
223
 
 
224
static void send_caf4(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
 
225
{
 
226
    guint keys[] = { GDK_Control_L, GDK_Alt_L, GDK_F4 };
 
227
    printf("Sending Ctrl+Alt+F4\n");
 
228
    vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
 
229
                          sizeof(keys)/sizeof(keys[0]));
 
230
}
 
231
 
 
232
static void send_caf5(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
 
233
{
 
234
    guint keys[] = { GDK_Control_L, GDK_Alt_L, GDK_F5 };
 
235
    printf("Sending Ctrl+Alt+F5\n");
 
236
    vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
 
237
                          sizeof(keys)/sizeof(keys[0]));
 
238
}
 
239
 
 
240
static void send_caf6(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
 
241
{
 
242
    guint keys[] = { GDK_Control_L, GDK_Alt_L, GDK_F6 };
 
243
    printf("Sending Ctrl+Alt+F6\n");
 
244
    vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
 
245
                          sizeof(keys)/sizeof(keys[0]));
 
246
}
 
247
 
 
248
static void send_caf7(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
 
249
{
 
250
    guint keys[] = { GDK_Control_L, GDK_Alt_L, GDK_F7 };
 
251
    printf("Sending Ctrl+Alt+F7\n");
 
252
    vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
 
253
                          sizeof(keys)/sizeof(keys[0]));
 
254
}
 
255
 
 
256
static void send_caf8(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
 
257
{
 
258
    guint keys[] = { GDK_Control_L, GDK_Alt_L, GDK_F8 };
 
259
    printf("Sending Ctrl+Alt+F8\n");
 
260
    vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
 
261
                          sizeof(keys)/sizeof(keys[0]));
 
262
}
 
263
 
 
264
static void send_cad(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
 
265
{
 
266
    guint keys[] = { GDK_Control_L, GDK_Alt_L, GDK_Delete };
 
267
    printf("Sending Ctrl+Alt+Delete\n");
 
268
    vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
 
269
                          sizeof(keys)/sizeof(keys[0]));
 
270
}
 
271
 
 
272
static void send_cab(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
 
273
{
 
274
    guint keys[] = { GDK_Control_L, GDK_Alt_L, GDK_BackSpace };
 
275
    printf("Sending Ctrl+Alt+Backspace\n");
 
276
    vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
 
277
                          sizeof(keys)/sizeof(keys[0]));
 
278
}
 
279
 
 
280
static void do_fullscreen(GtkWidget *menu, GtkWidget *window)
 
281
{
 
282
    if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menu)))
 
283
        gtk_window_fullscreen(GTK_WINDOW(window));
 
284
    else
 
285
        gtk_window_unfullscreen(GTK_WINDOW(window));
 
286
}
 
287
 
 
288
static void do_scaling(GtkWidget *menu, GtkWidget *vncdisplay)
 
289
{
 
290
    if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menu)))
 
291
        vnc_display_set_scaling(VNC_DISPLAY(vncdisplay), TRUE);
 
292
    else
 
293
        vnc_display_set_scaling(VNC_DISPLAY(vncdisplay), FALSE);
 
294
}
 
295
 
 
296
static void dialog_update_keysyms(GtkWidget *window, guint *keysyms, guint numsyms)
 
297
{
 
298
    gchar *keys;
 
299
    int i;
 
300
 
 
301
    keys = g_strdup("");
 
302
    for (i = 0; i < numsyms; i++)
 
303
        {
 
304
            keys = g_strdup_printf("%s%s%s", keys,
 
305
                                   (strlen(keys) > 0) ? "+" : " ", gdk_keyval_name(keysyms[i]));
 
306
        }
 
307
 
 
308
    gtk_label_set_text( GTK_LABEL(window), keys);
 
309
}
 
310
 
 
311
static gboolean dialog_key_ignore(int keyval)
 
312
{
 
313
    switch (keyval) {
 
314
    case GDK_Return:
 
315
    case GDK_Escape:
 
316
        return TRUE;
 
317
    }
 
318
 
 
319
    return FALSE;
 
320
}
 
321
 
 
322
static gboolean dialog_key_press(GtkWidget *window G_GNUC_UNUSED,
 
323
                                 GdkEvent *ev, VncGrabDefs *defs)
 
324
{
 
325
    gboolean keySymExists;
 
326
    int i;
 
327
 
 
328
    if (dialog_key_ignore(ev->key.keyval))
 
329
        return FALSE;
 
330
 
 
331
    if (defs->set && defs->curkeys)
 
332
        return FALSE;
 
333
 
 
334
    /* Check whether we already have keysym in array - i.e. it was handler by something else */
 
335
    keySymExists = FALSE;
 
336
    for (i = 0; i < defs->curkeys; i++) {
 
337
        if (defs->keysyms[i] == ev->key.keyval)
 
338
            keySymExists = TRUE;
 
339
    }
 
340
 
 
341
    if (!keySymExists) {
 
342
        defs->keysyms = g_renew(guint, defs->keysyms, defs->curkeys + 1);
 
343
        defs->keysyms[defs->curkeys] = ev->key.keyval;
 
344
        defs->curkeys++;
 
345
    }
 
346
 
 
347
    dialog_update_keysyms(defs->label, defs->keysyms, defs->curkeys);
 
348
 
 
349
    if (!ev->key.is_modifier) {
 
350
        defs->set = TRUE;
 
351
        defs->numkeys = defs->curkeys;
 
352
        defs->curkeys--;
 
353
    }
 
354
 
 
355
    return FALSE;
 
356
}
 
357
 
 
358
static gboolean dialog_key_release(GtkWidget *window G_GNUC_UNUSED,
 
359
                                   GdkEvent *ev, VncGrabDefs *defs)
 
360
{
 
361
    int i;
 
362
 
 
363
    if (dialog_key_ignore(ev->key.keyval))
 
364
        return FALSE;
 
365
 
 
366
    if (defs->set) {
 
367
        if (defs->curkeys == 0)
 
368
            defs->set = FALSE;
 
369
        if (defs->curkeys)
 
370
            defs->curkeys--;
 
371
        return FALSE;
 
372
    }
 
373
 
 
374
    for (i = 0; i < defs->curkeys; i++)
 
375
        {
 
376
            if (defs->keysyms[i] == ev->key.keyval)
 
377
                {
 
378
                    defs->keysyms[i] = defs->keysyms[defs->curkeys - 1];
 
379
                    defs->curkeys--;
 
380
                    defs->keysyms = g_renew(guint, defs->keysyms, defs->curkeys);
 
381
                }
 
382
        }
 
383
 
 
384
    dialog_update_keysyms(defs->label, defs->keysyms, defs->curkeys);
 
385
 
 
386
    return FALSE;
 
387
}
 
388
 
 
389
static void do_set_grab_keys(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *window)
 
390
{
 
391
    VncGrabDefs *defs;
 
392
    VncGrabSequence *seq;
 
393
    GtkWidget *dialog, *content_area, *label;
 
394
    gint result;
 
395
 
 
396
    dialog = gtk_dialog_new_with_buttons ("Key recorder",
 
397
                                          GTK_WINDOW(window),
 
398
                                          GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 
399
                                          GTK_STOCK_OK,
 
400
                                          GTK_RESPONSE_ACCEPT,
 
401
                                          GTK_STOCK_CANCEL,
 
402
                                          GTK_RESPONSE_REJECT,
 
403
                                          NULL);
 
404
 
 
405
    label = gtk_label_new("Please press desired grab key combination");
 
406
    defs = g_new(VncGrabDefs, 1);
 
407
    defs->label = label;
 
408
    defs->keysyms = 0;
 
409
    defs->numkeys = 0;
 
410
    defs->curkeys = 0;
 
411
    defs->set = FALSE;
 
412
    g_signal_connect(dialog, "key-press-event",
 
413
                     G_CALLBACK(dialog_key_press), defs);
 
414
    g_signal_connect(dialog, "key-release-event",
 
415
                     G_CALLBACK(dialog_key_release), defs);
 
416
    gtk_widget_set_size_request(dialog, 300, 100);
 
417
    content_area = gtk_dialog_get_content_area( GTK_DIALOG(dialog) );
 
418
    gtk_container_add( GTK_CONTAINER(content_area), label);
 
419
    gtk_widget_show_all(dialog);
 
420
 
 
421
    result = gtk_dialog_run(GTK_DIALOG(dialog));
 
422
    if (result == GTK_RESPONSE_ACCEPT) {
 
423
        /* Accepted so we make a grab sequence from it */
 
424
        seq = vnc_grab_sequence_new(defs->numkeys,
 
425
                                    defs->keysyms);
 
426
 
 
427
        vnc_display_set_grab_keys(VNC_DISPLAY(vnc), seq);
 
428
        set_title(VNC_DISPLAY(vnc), window, FALSE);
 
429
        vnc_grab_sequence_free(seq);
 
430
    }
 
431
    g_free(defs);
 
432
    gtk_widget_destroy(dialog);
 
433
}
 
434
 
 
435
static void vnc_credential(GtkWidget *vncdisplay, GValueArray *credList)
 
436
{
 
437
    GtkWidget *dialog = NULL;
 
438
    int response;
 
439
    unsigned int i, prompt = 0;
 
440
    const char **data;
 
441
 
 
442
    printf("Got credential request for %d credential(s)\n", credList->n_values);
 
443
 
 
444
    data = g_new0(const char *, credList->n_values);
 
445
 
 
446
    for (i = 0 ; i < credList->n_values ; i++) {
 
447
        GValue *cred = g_value_array_get_nth(credList, i);
 
448
        switch (g_value_get_enum(cred)) {
 
449
        case VNC_DISPLAY_CREDENTIAL_USERNAME:
 
450
        case VNC_DISPLAY_CREDENTIAL_PASSWORD:
 
451
            prompt++;
 
452
            break;
 
453
        case VNC_DISPLAY_CREDENTIAL_CLIENTNAME:
 
454
            data[i] = "gvncviewer";
 
455
        default:
 
456
            break;
 
457
        }
 
458
    }
 
459
 
 
460
    if (prompt) {
 
461
        GtkWidget **label, **entry, *box, *vbox;
 
462
        int row;
 
463
        dialog = gtk_dialog_new_with_buttons("Authentication required",
 
464
                                             NULL,
 
465
                                             0,
 
466
                                             GTK_STOCK_CANCEL,
 
467
                                             GTK_RESPONSE_CANCEL,
 
468
                                             GTK_STOCK_OK,
 
469
                                             GTK_RESPONSE_OK,
 
470
                                             NULL);
 
471
        gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
 
472
 
 
473
        box = gtk_table_new(credList->n_values, 2, FALSE);
 
474
        label = g_new(GtkWidget *, prompt);
 
475
        entry = g_new(GtkWidget *, prompt);
 
476
 
 
477
        for (i = 0, row =0 ; i < credList->n_values ; i++) {
 
478
            GValue *cred = g_value_array_get_nth(credList, i);
 
479
            entry[row] = gtk_entry_new();
 
480
            switch (g_value_get_enum(cred)) {
 
481
            case VNC_DISPLAY_CREDENTIAL_USERNAME:
 
482
                label[row] = gtk_label_new("Username:");
 
483
                break;
 
484
            case VNC_DISPLAY_CREDENTIAL_PASSWORD:
 
485
                label[row] = gtk_label_new("Password:");
 
486
                gtk_entry_set_activates_default(GTK_ENTRY(entry[row]), TRUE);
 
487
                break;
 
488
            default:
 
489
                continue;
 
490
            }
 
491
            if (g_value_get_enum (cred) == VNC_DISPLAY_CREDENTIAL_PASSWORD)
 
492
                gtk_entry_set_visibility (GTK_ENTRY (entry[row]), FALSE);
 
493
 
 
494
            gtk_table_attach(GTK_TABLE(box), label[i], 0, 1, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3);
 
495
            gtk_table_attach(GTK_TABLE(box), entry[i], 1, 2, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3);
 
496
            row++;
 
497
        }
 
498
 
 
499
        vbox = gtk_bin_get_child(GTK_BIN(dialog));
 
500
        gtk_container_add(GTK_CONTAINER(vbox), box);
 
501
 
 
502
        gtk_widget_show_all(dialog);
 
503
        response = gtk_dialog_run(GTK_DIALOG(dialog));
 
504
        gtk_widget_hide(GTK_WIDGET(dialog));
 
505
 
 
506
        if (response == GTK_RESPONSE_OK) {
 
507
            for (i = 0, row = 0 ; i < credList->n_values ; i++) {
 
508
                GValue *cred = g_value_array_get_nth(credList, i);
 
509
                switch (g_value_get_enum(cred)) {
 
510
                case VNC_DISPLAY_CREDENTIAL_USERNAME:
 
511
                case VNC_DISPLAY_CREDENTIAL_PASSWORD:
 
512
                    data[i] = gtk_entry_get_text(GTK_ENTRY(entry[row]));
 
513
                    break;
 
514
                default:
 
515
                    continue;
 
516
                }
 
517
                row++;
 
518
            }
 
519
        }
 
520
    }
 
521
 
 
522
    for (i = 0 ; i < credList->n_values ; i++) {
 
523
        GValue *cred = g_value_array_get_nth(credList, i);
 
524
        if (data[i]) {
 
525
            if (vnc_display_set_credential(VNC_DISPLAY(vncdisplay),
 
526
                                           g_value_get_enum(cred),
 
527
                                           data[i])) {
 
528
                printf("Failed to set credential type %d\n", g_value_get_enum(cred));
 
529
                vnc_display_close(VNC_DISPLAY(vncdisplay));
 
530
            }
 
531
        } else {
 
532
            printf("Unsupported credential type %d\n", g_value_get_enum(cred));
 
533
            vnc_display_close(VNC_DISPLAY(vncdisplay));
 
534
        }
 
535
    }
 
536
 
 
537
    g_free(data);
 
538
    if (dialog)
 
539
        gtk_widget_destroy(GTK_WIDGET(dialog));
 
540
}
 
541
 
 
542
#if WITH_LIBVIEW
 
543
static gboolean window_state_event(GtkWidget *widget,
 
544
                                   GdkEventWindowState *event,
 
545
                                   gpointer data)
 
546
{
 
547
    ViewAutoDrawer *drawer = VIEW_AUTODRAWER(data);
 
548
 
 
549
    if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
 
550
        if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
 
551
            vnc_display_force_grab(VNC_DISPLAY(vnc), TRUE);
 
552
            ViewAutoDrawer_SetActive(drawer, TRUE);
 
553
        } else {
 
554
            vnc_display_force_grab(VNC_DISPLAY(vnc), FALSE);
 
555
            ViewAutoDrawer_SetActive(drawer, FALSE);
 
556
        }
 
557
    }
 
558
 
 
559
    return FALSE;
 
560
}
 
561
#endif
 
562
 
 
563
int main(int argc, char **argv)
 
564
{
 
565
    gchar *name;
 
566
    GOptionContext *context;
 
567
    GError *error = NULL;
 
568
    char port[1024], hostname[1024];
 
569
    char *display;
 
570
    GtkWidget *window;
 
571
    GtkWidget *layout;
 
572
    GtkWidget *menubar;
 
573
    GtkWidget *sendkey, *view, *settings;
 
574
    GtkWidget *submenu;
 
575
    GtkWidget *caf1;
 
576
    GtkWidget *caf2;
 
577
    GtkWidget *caf3;
 
578
    GtkWidget *caf4;
 
579
    GtkWidget *caf5;
 
580
    GtkWidget *caf6;
 
581
    GtkWidget *caf7;
 
582
    GtkWidget *caf8;
 
583
    GtkWidget *cad;
 
584
    GtkWidget *cab;
 
585
    GtkWidget *fullscreen;
 
586
    GtkWidget *scaling;
 
587
    GtkWidget *showgrabkeydlg;
 
588
    const char *help_msg = "Run 'gvncviewer --help' to see a full list of available command line options";
 
589
 
 
590
    name = g_strdup_printf("- Simple VNC Client on Gtk-VNC %s",
 
591
                           vnc_util_get_version_string());
 
592
 
 
593
    /* Setup command line options */
 
594
    context = g_option_context_new (name);
 
595
    g_option_context_add_main_entries (context, options, NULL);
 
596
    g_option_context_add_group (context, gtk_get_option_group (TRUE));
 
597
    g_option_context_add_group (context, vnc_display_get_option_group ());
 
598
    g_option_context_parse (context, &argc, &argv, &error);
 
599
    if (error) {
 
600
        g_print ("%s\n%s\n",
 
601
                 error->message,
 
602
                 help_msg);
 
603
        g_error_free (error);
 
604
        return 1;
 
605
    }
 
606
    if (!args || (g_strv_length(args) != 1)) {
 
607
        fprintf(stderr, "Usage: gvncviewer [hostname][:display]\n%s\n", help_msg);
 
608
        return 1;
 
609
    }
 
610
 
 
611
    vnc = vnc_display_new();
 
612
 
 
613
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
614
#if WITH_LIBVIEW
 
615
    layout = ViewAutoDrawer_New();
 
616
#else
 
617
    layout = gtk_vbox_new(FALSE, 0);
 
618
#endif
 
619
    menubar = gtk_menu_bar_new();
 
620
 
 
621
#if HAVE_PULSEAUDIO
 
622
    pa = vnc_audio_pulse_new();
 
623
#endif
 
624
 
 
625
    gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
 
626
 
 
627
    sendkey = gtk_menu_item_new_with_mnemonic("_Send Key");
 
628
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), sendkey);
 
629
 
 
630
    submenu = gtk_menu_new();
 
631
 
 
632
    caf1 = gtk_menu_item_new_with_mnemonic("Ctrl+Alt+F_1");
 
633
    caf2 = gtk_menu_item_new_with_mnemonic("Ctrl+Alt+F_2");
 
634
    caf3 = gtk_menu_item_new_with_mnemonic("Ctrl+Alt+F_3");
 
635
    caf4 = gtk_menu_item_new_with_mnemonic("Ctrl+Alt+F_4");
 
636
    caf5 = gtk_menu_item_new_with_mnemonic("Ctrl+Alt+F_5");
 
637
    caf6 = gtk_menu_item_new_with_mnemonic("Ctrl+Alt+F_6");
 
638
    caf7 = gtk_menu_item_new_with_mnemonic("Ctrl+Alt+F_7");
 
639
    caf8 = gtk_menu_item_new_with_mnemonic("Ctrl+Alt+F_8");
 
640
    cad = gtk_menu_item_new_with_mnemonic("Ctrl+Alt+_Del");
 
641
    cab = gtk_menu_item_new_with_mnemonic("Ctrl+Alt+_Backspace");
 
642
 
 
643
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf1);
 
644
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf2);
 
645
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf3);
 
646
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf4);
 
647
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf5);
 
648
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf6);
 
649
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf7);
 
650
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf8);
 
651
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), cad);
 
652
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), cab);
 
653
 
 
654
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(sendkey), submenu);
 
655
 
 
656
    view = gtk_menu_item_new_with_mnemonic("_View");
 
657
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), view);
 
658
 
 
659
    submenu = gtk_menu_new();
 
660
 
 
661
    fullscreen = gtk_check_menu_item_new_with_mnemonic("_Full Screen");
 
662
    scaling = gtk_check_menu_item_new_with_mnemonic("Scaled display");
 
663
 
 
664
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), fullscreen);
 
665
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), scaling);
 
666
 
 
667
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), submenu);
 
668
 
 
669
    settings = gtk_menu_item_new_with_mnemonic("_Settings");
 
670
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), settings);
 
671
 
 
672
    submenu = gtk_menu_new();
 
673
 
 
674
    showgrabkeydlg = gtk_menu_item_new_with_mnemonic("_Set grab keys");
 
675
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), showgrabkeydlg);
 
676
 
 
677
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings), submenu);
 
678
 
 
679
#if WITH_LIBVIEW
 
680
    ViewAutoDrawer_SetActive(VIEW_AUTODRAWER(layout), FALSE);
 
681
    ViewOvBox_SetOver(VIEW_OV_BOX(layout), menubar);
 
682
    ViewOvBox_SetUnder(VIEW_OV_BOX(layout), vnc);
 
683
#else
 
684
    gtk_box_pack_start(GTK_BOX(layout), menubar, FALSE, TRUE, 0);
 
685
    gtk_box_pack_start(GTK_BOX(layout), vnc, TRUE, TRUE, 0);
 
686
#endif
 
687
    gtk_container_add(GTK_CONTAINER(window), layout);
 
688
    gtk_widget_realize(vnc);
 
689
 
 
690
    snprintf(hostname, sizeof(hostname), "%s", args[0]);
 
691
    display = strchr(hostname, ':');
 
692
 
 
693
    if (display) {
 
694
        *display = 0;
 
695
        snprintf(port, sizeof(port), "%d", 5900 + atoi(display + 1));
 
696
    } else
 
697
        snprintf(port, sizeof(port), "%d", 5900);
 
698
 
 
699
    if (!*hostname)
 
700
        snprintf(hostname, sizeof(hostname), "%s", "127.0.0.1");
 
701
    vnc_display_open_host(VNC_DISPLAY(vnc), hostname, port);
 
702
    vnc_display_set_keyboard_grab(VNC_DISPLAY(vnc), TRUE);
 
703
    vnc_display_set_pointer_grab(VNC_DISPLAY(vnc), TRUE);
 
704
 
 
705
    if (!gtk_widget_is_composited(window)) {
 
706
        vnc_display_set_scaling(VNC_DISPLAY(vnc), TRUE);
 
707
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(scaling), TRUE);
 
708
    }
 
709
 
 
710
    g_signal_connect(window, "delete-event",
 
711
                     G_CALLBACK(gtk_main_quit), NULL);
 
712
    g_signal_connect(vnc, "vnc-connected",
 
713
                     G_CALLBACK(vnc_connected), NULL);
 
714
    g_signal_connect(vnc, "vnc-initialized",
 
715
                     G_CALLBACK(vnc_initialized), window);
 
716
    g_signal_connect(vnc, "vnc-disconnected",
 
717
                     G_CALLBACK(vnc_disconnected), NULL);
 
718
    g_signal_connect(vnc, "vnc-auth-credential",
 
719
                     G_CALLBACK(vnc_credential), NULL);
 
720
    g_signal_connect(vnc, "vnc-auth-failure",
 
721
                     G_CALLBACK(vnc_auth_failure), NULL);
 
722
 
 
723
    g_signal_connect(vnc, "vnc-desktop-resize",
 
724
                     G_CALLBACK(vnc_desktop_resize), NULL);
 
725
 
 
726
    g_signal_connect(vnc, "vnc-pointer-grab",
 
727
                     G_CALLBACK(vnc_grab), window);
 
728
    g_signal_connect(vnc, "vnc-pointer-ungrab",
 
729
                     G_CALLBACK(vnc_ungrab), window);
 
730
 
 
731
    g_signal_connect(window, "key-press-event",
 
732
                     G_CALLBACK(vnc_screenshot), vnc);
 
733
 
 
734
    g_signal_connect(caf1, "activate",
 
735
                     G_CALLBACK(send_caf1), vnc);
 
736
    g_signal_connect(caf2, "activate",
 
737
                     G_CALLBACK(send_caf2), vnc);
 
738
    g_signal_connect(caf3, "activate",
 
739
                     G_CALLBACK(send_caf3), vnc);
 
740
    g_signal_connect(caf4, "activate",
 
741
                     G_CALLBACK(send_caf4), vnc);
 
742
    g_signal_connect(caf5, "activate",
 
743
                     G_CALLBACK(send_caf5), vnc);
 
744
    g_signal_connect(caf6, "activate",
 
745
                     G_CALLBACK(send_caf6), vnc);
 
746
    g_signal_connect(caf7, "activate",
 
747
                     G_CALLBACK(send_caf7), vnc);
 
748
    g_signal_connect(caf8, "activate",
 
749
                     G_CALLBACK(send_caf8), vnc);
 
750
    g_signal_connect(cad, "activate",
 
751
                     G_CALLBACK(send_cad), vnc);
 
752
    g_signal_connect(cab, "activate",
 
753
                     G_CALLBACK(send_cab), vnc);
 
754
    g_signal_connect(showgrabkeydlg, "activate",
 
755
                     G_CALLBACK(do_set_grab_keys), window);
 
756
    g_signal_connect(fullscreen, "toggled",
 
757
                     G_CALLBACK(do_fullscreen), window);
 
758
    g_signal_connect(scaling, "toggled",
 
759
                     G_CALLBACK(do_scaling), vnc);
 
760
#if WITH_LIBVIEW
 
761
    g_signal_connect(window, "window-state-event",
 
762
                     G_CALLBACK(window_state_event), layout);
 
763
#endif
 
764
 
 
765
    gtk_main();
 
766
 
 
767
    return 0;
 
768
}
 
769
 
 
770
/*
 
771
 * Local variables:
 
772
 *  c-indent-level: 4
 
773
 *  c-basic-offset: 4
 
774
 *  indent-tabs-mode: nil
 
775
 * End:
 
776
 */