VNCViewer
/* $Id$ */
static char const _copyright[] =
"Copyright © 2006 Anthony Liguori <anthony@codemonkey.ws>\n"
"Copyright © 2015-2020 Pierre Pronchery <khorben@defora.org>";
/* This file is part of DeforaOS Desktop VNCViewer */
static char const _license[] =
"This software is originally based on the GTK VNC Widget library.\n"
"\n"
"Copyright © 2006 Anthony Liguori <anthony@codemonkey.ws>\n"
"\n"
"This library is free software; you can redistribute it and/or\n"
"modify it under the terms of the GNU Lesser General Public\n"
"License as published by the Free Software Foundation; either\n"
"version 2.0 of the License, or (at your option) any later version.\n"
"\n"
"This library is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
"Lesser General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU Lesser General Public\n"
"License along with this library; if not, write to the Free Software\n"
"Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA";
/* FIXME:
* - disable grabbing mouse/keyboard on disconnect
* - fix message dialog when the connection is already busy */
#include <vncdisplay.h>
#include <vncutil.h>
#ifdef HAVE_PULSEAUDIO
#include <vncaudiopulse.h>
#endif
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include <Desktop.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <libintl.h>
#ifdef HAVE_GIOUNIX
#include <gio/gunixsocketaddress.h>
#endif
#if WITH_LIBVIEW
#include <libview/autoDrawer.h>
#endif
#include "vncviewer.h"
#include "../config.h"
#define _(string) gettext(string)
/* constants */
#ifndef PROGNAME_VNCVIEWER
# define PROGNAME_VNCVIEWER "vncviewer"
#endif
#ifdef HAVE_PULSEAUDIO
static VncAudioPulse *pa = NULL;
#endif
static GtkWidget *vnc = NULL;
static GtkWidget *status;
static GtkWidget *statusbar;
static char const * _authors[] = {
"Anthony Liguori <anthony@codemonkey.ws>",
"Pierre Pronchery <khorben@defora.org>",
NULL
};
typedef struct {
GtkWidget *label;
guint curkeys;
guint numkeys;
guint *keysyms;
gboolean set;
} VncGrabDefs;
gboolean enable_mnemonics_save;
GtkAccelGroup *accel_group;
gboolean accel_enabled = TRUE;
GValue accel_setting;
GSList *accel_list;
static void set_status(char const * format, ...)
{
va_list ap;
guint id;
gchar *status;
va_start(ap, format);
if (vnc != NULL) {
id = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "");
status = g_strdup_vprintf(format, ap);
gtk_statusbar_pop(GTK_STATUSBAR(statusbar), id);
gtk_statusbar_push(GTK_STATUSBAR(statusbar), id, status);
g_free(status);
} else {
fputs(PROGNAME_VNCVIEWER ": ", stderr);
vfprintf(stderr, format, ap);
fputc('\n', stderr);
}
va_end(ap);
}
static void set_title(VncDisplay *vncdisplay, GtkWidget *window,
gboolean grabbed)
{
const gchar *name = vnc_display_get_name(VNC_DISPLAY(vncdisplay));
VncGrabSequence *seq = vnc_display_get_grab_keys(vncdisplay);
gchar *seqstr = vnc_grab_sequence_as_string(seq);
gchar *title;
if (grabbed) {
if (name != NULL)
title = g_strdup_printf(
_("%s - %s (Press %s to release pointer)"),
PACKAGE, name, seqstr);
else
title = g_strdup_printf(
_("%s (Press %s to release pointer)"),
PACKAGE, seqstr);
}
else if(name != NULL)
title = g_strdup_printf("%s - %s", PACKAGE, name);
else
title = g_strdup(PACKAGE);
gtk_window_set_title(GTK_WINDOW(window), title);
g_free(seqstr);
g_free(title);
}
static void vnc_screenshot(GtkWidget *widget G_GNUC_UNUSED, gpointer data)
{
GtkWidget * vncdisplay = data;
const char filename[] = "vncviewer.png";
GdkPixbuf * pix;
if((pix = vnc_display_get_pixbuf(VNC_DISPLAY(vncdisplay))) != NULL)
{
gdk_pixbuf_save(pix, filename, "png", NULL, "tEXt::Generator App",
"vncviewer", NULL);
g_object_unref(pix);
set_status(_("Screenshot saved to %s"), filename);
}
}
static void
vnc_disable_modifiers(GtkWindow *window)
{
GtkSettings *settings = gtk_settings_get_default();
GValue empty;
GSList *accels;
if (!accel_enabled)
return;
/* This stops F10 activating menu bar */
memset(&empty, 0, sizeof empty);
g_value_init(&empty, G_TYPE_STRING);
g_object_get_property(G_OBJECT(settings), "gtk-menu-bar-accel", &accel_setting);
g_object_set_property(G_OBJECT(settings), "gtk-menu-bar-accel", &empty);
/* This stops global accelerators like Ctrl+Q == Quit */
for (accels = accel_list ; accels ; accels = accels->next) {
if (accel_group == accels->data)
continue;
gtk_window_remove_accel_group(GTK_WINDOW(window), accels->data);
}
/* This stops menu bar shortcuts like Alt+F == File */
g_object_get(settings,
"gtk-enable-mnemonics", &enable_mnemonics_save,
NULL);
g_object_set(settings,
"gtk-enable-mnemonics", FALSE,
NULL);
accel_enabled = FALSE;
}
static void
vnc_enable_modifiers(GtkWindow *window)
{
GtkSettings *settings = gtk_settings_get_default();
GSList *accels;
if (accel_enabled)
return;
/* This allows F10 activating menu bar */
g_object_set_property(G_OBJECT(settings), "gtk-menu-bar-accel", &accel_setting);
/* This allows global accelerators like Ctrl+Q == Quit */
for (accels = accel_list ; accels ; accels = accels->next) {
if (accel_group == accels->data)
continue;
gtk_window_add_accel_group(GTK_WINDOW(window), accels->data);
}
/* This allows menu bar shortcuts like Alt+F == File */
g_object_set(settings,
"gtk-enable-mnemonics", enable_mnemonics_save,
NULL);
accel_enabled = TRUE;
}
static void vnc_key_grab(GtkWidget *vncdisplay G_GNUC_UNUSED, GtkWidget *window)
{
vnc_disable_modifiers(GTK_WINDOW(window));
}
static void vnc_key_ungrab(GtkWidget *vncdisplay G_GNUC_UNUSED, GtkWidget *window)
{
vnc_enable_modifiers(GTK_WINDOW(window));
}
static void vnc_mouse_grab(GtkWidget *vncdisplay, GtkWidget *window)
{
set_title(VNC_DISPLAY(vncdisplay), window, TRUE);
}
static void vnc_mouse_ungrab(GtkWidget *vncdisplay, GtkWidget *window)
{
set_title(VNC_DISPLAY(vncdisplay), window, FALSE);
}
static int connected = 0;
static void vnc_connected(GtkWidget *vncdisplay G_GNUC_UNUSED)
{
set_status(_("Connected to server"));
gtk_image_set_from_icon_name(GTK_IMAGE(status), "gtk-connect",
GTK_ICON_SIZE_MENU);
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_widget_set_tooltip_text(status, _("Connected"));
#endif
connected = 1;
}
static void vnc_initialized(GtkWidget *vncdisplay, GtkWidget *window)
{
set_status(_("Connection initialized"));
set_title(VNC_DISPLAY(vncdisplay), window, FALSE);
gtk_widget_show_all(window);
#ifdef HAVE_PULSEAUDIO
VncConnection *conn;
VncAudioFormat format = {
VNC_AUDIO_FORMAT_RAW_S32,
2,
44100,
};
conn = vnc_display_get_connection(VNC_DISPLAY(vncdisplay));
vnc_connection_set_audio_format(conn, &format);
vnc_connection_set_audio(conn, VNC_AUDIO(pa));
vnc_connection_audio_enable(conn);
#endif
}
static void vnc_auth_failure(GtkWidget *vncdisplay G_GNUC_UNUSED,
const char *msg)
{
set_status(_("Authentication failed '%s'"), msg ? msg : "");
}
static void vnc_desktop_resize(GtkWidget *vncdisplay G_GNUC_UNUSED,
int width, int height)
{
set_status(_("Remote desktop size changed to %dx%d"), width, height);
}
static void vnc_disconnected(GtkWidget *vncdisplay G_GNUC_UNUSED,
GtkWidget *window)
{
if(connected)
set_status(_("Disconnected from server"));
else
set_status(_("Failed to connect to server"));
gtk_image_set_from_icon_name(GTK_IMAGE(status), "gtk-disconnect",
GTK_ICON_SIZE_MENU);
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_widget_set_tooltip_text(status, _("Disconnected"));
#endif
gtk_widget_show_all(window);
connected = 0;
}
static void send_caf1(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
{
guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_F1 };
set_status(_("Sending Ctrl+Alt+F1"));
vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
sizeof(keys)/sizeof(keys[0]));
}
static void send_caf2(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
{
guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_F2 };
set_status(_("Sending Ctrl+Alt+F2"));
vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
sizeof(keys)/sizeof(keys[0]));
}
static void send_caf3(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
{
guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_F3 };
set_status(_("Sending Ctrl+Alt+F3"));
vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
sizeof(keys)/sizeof(keys[0]));
}
static void send_caf4(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
{
guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_F4 };
set_status(_("Sending Ctrl+Alt+F4"));
vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
sizeof(keys)/sizeof(keys[0]));
}
static void send_caf5(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
{
guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_F5 };
set_status(_("Sending Ctrl+Alt+F5"));
vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
sizeof(keys)/sizeof(keys[0]));
}
static void send_caf6(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
{
guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_F6 };
set_status(_("Sending Ctrl+Alt+F6"));
vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
sizeof(keys)/sizeof(keys[0]));
}
static void send_caf7(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
{
guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_F7 };
set_status(_("Sending Ctrl+Alt+F7"));
vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
sizeof(keys)/sizeof(keys[0]));
}
static void send_caf8(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
{
guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_F8 };
set_status(_("Sending Ctrl+Alt+F8"));
vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
sizeof(keys)/sizeof(keys[0]));
}
static void send_cad(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
{
guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_Delete };
set_status(_("Sending Ctrl+Alt+Delete"));
vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
sizeof(keys)/sizeof(keys[0]));
}
static void send_cab(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *vncdisplay)
{
guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_BackSpace };
set_status(_("Sending Ctrl+Alt+Backspace"));
vnc_display_send_keys(VNC_DISPLAY(vncdisplay), keys,
sizeof(keys)/sizeof(keys[0]));
}
static void do_about(GtkWidget *menu, GtkWidget *window)
{
GtkWidget *dialog;
(void) menu;
dialog = gtk_about_dialog_new();
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(window));
gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(dialog), _authors);
gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(dialog),
_("VNC client for the DeforaOS desktop"));
gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(dialog), _copyright);
gtk_about_dialog_set_logo_icon_name(GTK_ABOUT_DIALOG(dialog),
"gnome-remote-desktop");
gtk_about_dialog_set_license(GTK_ABOUT_DIALOG(dialog), _license);
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(dialog), PACKAGE);
#else
gtk_about_dialog_set_name(GTK_ABOUT_DIALOG(dialog), PACKAGE);
#endif
gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), VERSION);
gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(dialog),
"https://www.defora.org/");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
static void do_fullscreen(GtkWidget *menu, GtkWidget *window)
{
if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menu))) {
gtk_widget_hide(statusbar);
gtk_window_fullscreen(GTK_WINDOW(window));
} else {
gtk_window_unfullscreen(GTK_WINDOW(window));
gtk_widget_show(statusbar);
}
}
static void do_scaling(GtkWidget *menu, GtkWidget *vncdisplay)
{
if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menu)))
vnc_display_set_scaling(VNC_DISPLAY(vncdisplay), TRUE);
else
vnc_display_set_scaling(VNC_DISPLAY(vncdisplay), FALSE);
}
static void dialog_update_keysyms(GtkWidget *window, guint *keysyms, guint numsyms)
{
gchar *keys;
guint i;
keys = g_strdup("");
for (i = 0; i < numsyms; i++)
keys = g_strdup_printf("%s%s%s", keys,
(strlen(keys) > 0) ? "+" : " ", gdk_keyval_name(keysyms[i]));
gtk_label_set_text( GTK_LABEL(window), keys);
}
static gboolean dialog_key_ignore(int keyval)
{
switch (keyval) {
case GDK_KEY_Return:
case GDK_KEY_Escape:
return TRUE;
default:
return FALSE;
}
}
static gboolean dialog_key_press(GtkWidget *window G_GNUC_UNUSED,
GdkEvent *ev, VncGrabDefs *defs)
{
gboolean keySymExists;
guint i;
if (dialog_key_ignore(ev->key.keyval))
return FALSE;
if (defs->set && defs->curkeys)
return FALSE;
/* Check whether we already have keysym in array - i.e. it was handler by something else */
keySymExists = FALSE;
for (i = 0; i < defs->curkeys; i++) {
if (defs->keysyms[i] == ev->key.keyval)
keySymExists = TRUE;
}
if (!keySymExists) {
defs->keysyms = g_renew(guint, defs->keysyms, defs->curkeys + 1);
defs->keysyms[defs->curkeys] = ev->key.keyval;
defs->curkeys++;
}
dialog_update_keysyms(defs->label, defs->keysyms, defs->curkeys);
if (!ev->key.is_modifier) {
defs->set = TRUE;
defs->numkeys = defs->curkeys;
defs->curkeys--;
}
return FALSE;
}
static gboolean dialog_key_release(GtkWidget *window G_GNUC_UNUSED,
GdkEvent *ev, VncGrabDefs *defs)
{
guint i;
if (dialog_key_ignore(ev->key.keyval))
return FALSE;
if (defs->set) {
if (defs->curkeys == 0)
defs->set = FALSE;
else
defs->curkeys--;
return FALSE;
}
for (i = 0; i < defs->curkeys; i++)
if (defs->keysyms[i] == ev->key.keyval)
{
defs->keysyms[i] = defs->keysyms[defs->curkeys - 1];
defs->curkeys--;
defs->keysyms = g_renew(guint, defs->keysyms, defs->curkeys);
}
dialog_update_keysyms(defs->label, defs->keysyms, defs->curkeys);
return FALSE;
}
static void do_set_grab_keys(GtkWidget *menu G_GNUC_UNUSED, GtkWidget *window)
{
VncGrabDefs *defs;
VncGrabSequence *seq;
GtkWidget *dialog, *content_area, *label;
gint result;
dialog = gtk_message_dialog_new(GTK_WINDOW(window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL,
#if GTK_CHECK_VERSION(2, 6, 0)
"%s", _("Key recorder"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
#endif
_("Please press desired grab key combination"));
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_message_dialog_set_image(GTK_MESSAGE_DIALOG(dialog),
gtk_image_new_from_icon_name("gtk-media-record",
GTK_ICON_SIZE_DIALOG));
#endif
gtk_window_set_title(GTK_WINDOW(dialog), _("Key recorder"));
label = gtk_label_new("");
defs = g_new(VncGrabDefs, 1);
defs->label = label;
defs->keysyms = 0;
defs->numkeys = 0;
defs->curkeys = 0;
defs->set = FALSE;
g_signal_connect(dialog, "key-press-event",
G_CALLBACK(dialog_key_press), defs);
g_signal_connect(dialog, "key-release-event",
G_CALLBACK(dialog_key_release), defs);
#if GTK_CHECK_VERSION(2, 14, 0)
content_area = gtk_dialog_get_content_area( GTK_DIALOG(dialog) );
#else
content_area = dialog->vbox;
#endif
gtk_container_add( GTK_CONTAINER(content_area), label);
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT) {
/* Accepted so we make a grab sequence from it */
seq = vnc_grab_sequence_new(defs->numkeys,
defs->keysyms);
vnc_display_set_grab_keys(VNC_DISPLAY(vnc), seq);
set_title(VNC_DISPLAY(vnc), window, FALSE);
vnc_grab_sequence_free(seq);
}
g_free(defs);
gtk_widget_destroy(dialog);
}
static void vnc_credential(GtkWidget *vncdisplay, GValueArray *credList)
{
GtkWidget *dialog = NULL;
int response;
unsigned int i, prompt = 0;
const char **data;
set_status(_("Got credential request for %d credential(s)"),
credList->n_values);
data = g_new0(const char *, credList->n_values);
for (i = 0 ; i < credList->n_values ; i++) {
GValue *cred = g_value_array_get_nth(credList, i);
switch (g_value_get_enum(cred)) {
case VNC_DISPLAY_CREDENTIAL_USERNAME:
case VNC_DISPLAY_CREDENTIAL_PASSWORD:
prompt++;
break;
case VNC_DISPLAY_CREDENTIAL_CLIENTNAME:
data[i] = PACKAGE;
default:
break;
}
}
if (prompt) {
GtkWidget **label, **entry, *box, *vbox;
int row;
dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_OK_CANCEL,
#if GTK_CHECK_VERSION(2, 6, 0)
"%s", _("Authentication required"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
#endif
"");
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_message_dialog_set_image(GTK_MESSAGE_DIALOG(dialog),
gtk_image_new_from_icon_name(
"gtk-dialog-authentication",
GTK_ICON_SIZE_DIALOG));
#endif
gtk_window_set_title(GTK_WINDOW(dialog), _("Authentication required"));
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
box = gtk_table_new(credList->n_values, 2, FALSE);
label = g_new(GtkWidget *, prompt);
entry = g_new(GtkWidget *, prompt);
for (i = 0, row =0 ; i < credList->n_values ; i++) {
GValue *cred = g_value_array_get_nth(credList, i);
entry[row] = gtk_entry_new();
switch (g_value_get_enum(cred)) {
case VNC_DISPLAY_CREDENTIAL_USERNAME:
label[row] = gtk_label_new(_("Username: "));
break;
case VNC_DISPLAY_CREDENTIAL_PASSWORD:
label[row] = gtk_label_new(_("Password: "));
gtk_entry_set_activates_default(GTK_ENTRY(entry[row]), TRUE);
break;
default:
continue;
}
if (g_value_get_enum (cred) == VNC_DISPLAY_CREDENTIAL_PASSWORD)
gtk_entry_set_visibility (GTK_ENTRY (entry[row]), FALSE);
gtk_table_attach(GTK_TABLE(box), label[i], 0, 1, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3);
gtk_table_attach(GTK_TABLE(box), entry[i], 1, 2, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3);
row++;
}
vbox = gtk_bin_get_child(GTK_BIN(dialog));
gtk_container_add(GTK_CONTAINER(vbox), box);
gtk_widget_show_all(dialog);
response = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_hide(GTK_WIDGET(dialog));
if (response == GTK_RESPONSE_OK) {
for (i = 0, row = 0 ; i < credList->n_values ; i++) {
GValue *cred = g_value_array_get_nth(credList, i);
switch (g_value_get_enum(cred)) {
case VNC_DISPLAY_CREDENTIAL_USERNAME:
case VNC_DISPLAY_CREDENTIAL_PASSWORD:
data[i] = gtk_entry_get_text(GTK_ENTRY(entry[row]));
break;
default:
continue;
}
row++;
}
}
}
for (i = 0 ; i < credList->n_values ; i++) {
GValue *cred = g_value_array_get_nth(credList, i);
if (data[i]) {
if (vnc_display_set_credential(VNC_DISPLAY(vncdisplay),
g_value_get_enum(cred),
data[i])) {
set_status(_("Failed to set credential type %d"),
g_value_get_enum(cred));
vnc_display_close(VNC_DISPLAY(vncdisplay));
}
} else {
set_status(_("Unsupported credential type %d"),
g_value_get_enum(cred));
vnc_display_close(VNC_DISPLAY(vncdisplay));
}
}
g_free(data);
if (dialog)
gtk_widget_destroy(GTK_WIDGET(dialog));
}
#if WITH_LIBVIEW
static gboolean window_state_event(GtkWidget *widget,
GdkEventWindowState *event,
gpointer data)
{
ViewAutoDrawer *drawer = VIEW_AUTODRAWER(data);
if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
vnc_display_force_grab(VNC_DISPLAY(vnc), TRUE);
ViewAutoDrawer_SetActive(drawer, TRUE);
} else {
vnc_display_force_grab(VNC_DISPLAY(vnc), FALSE);
ViewAutoDrawer_SetActive(drawer, FALSE);
}
}
return FALSE;
}
#endif
int vncviewer(gchar ** args)
{
GtkWidget *window;
GtkWidget *layout;
GtkWidget *menubar;
GtkWidget *file, *sendkey, *view, *settings, *help;
GtkWidget *submenu;
GtkWidget *screenshot;
GtkWidget *menuitem;
GtkWidget *close;
GtkWidget *caf1;
GtkWidget *caf2;
GtkWidget *caf3;
GtkWidget *caf4;
GtkWidget *caf5;
GtkWidget *caf6;
GtkWidget *caf7;
GtkWidget *caf8;
GtkWidget *cad;
GtkWidget *cab;
GtkWidget *fullscreen;
GtkWidget *scaling;
GtkWidget *about;
GtkWidget *showgrabkeydlg;
GtkWidget *widget;
GSList *accels;
gchar *tmp;
gchar *hostname;
gchar *port;
vnc = vnc_display_new();
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_icon_name(GTK_WINDOW(window), "gnome-remote-desktop");
#if WITH_LIBVIEW
layout = ViewAutoDrawer_New();
#elif GTK_CHECK_VERSION(3, 0, 0)
layout = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#else
layout = gtk_vbox_new(FALSE, 0);
#endif
menubar = gtk_menu_bar_new();
#ifdef HAVE_PULSEAUDIO
pa = vnc_audio_pulse_new();
#endif
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
gtk_window_set_title(GTK_WINDOW(window), PACKAGE);
file = gtk_menu_item_new_with_mnemonic(_("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
submenu = gtk_menu_new();
screenshot = gtk_image_menu_item_new_with_mnemonic(_("Save _screenshot"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(screenshot),
gtk_image_new_from_icon_name("gtk-save",
GTK_ICON_SIZE_MENU));
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), screenshot);
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem);
close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), close);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), submenu);
sendkey = gtk_menu_item_new_with_mnemonic(_("_Send Key"));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), sendkey);
submenu = gtk_menu_new();
caf1 = gtk_menu_item_new_with_mnemonic(_("Ctrl+Alt+F_1"));
caf2 = gtk_menu_item_new_with_mnemonic(_("Ctrl+Alt+F_2"));
caf3 = gtk_menu_item_new_with_mnemonic(_("Ctrl+Alt+F_3"));
caf4 = gtk_menu_item_new_with_mnemonic(_("Ctrl+Alt+F_4"));
caf5 = gtk_menu_item_new_with_mnemonic(_("Ctrl+Alt+F_5"));
caf6 = gtk_menu_item_new_with_mnemonic(_("Ctrl+Alt+F_6"));
caf7 = gtk_menu_item_new_with_mnemonic(_("Ctrl+Alt+F_7"));
caf8 = gtk_menu_item_new_with_mnemonic(_("Ctrl+Alt+F_8"));
cad = gtk_menu_item_new_with_mnemonic(_("Ctrl+Alt+_Del"));
cab = gtk_menu_item_new_with_mnemonic(_("Ctrl+Alt+_Backspace"));
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf1);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf2);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf3);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf4);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf5);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf6);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf7);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), caf8);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), cad);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), cab);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(sendkey), submenu);
view = gtk_menu_item_new_with_mnemonic(_("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), view);
submenu = gtk_menu_new();
fullscreen = gtk_check_menu_item_new_with_mnemonic(_("_Full Screen"));
scaling = gtk_check_menu_item_new_with_mnemonic(_("Scaled display"));
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), fullscreen);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), scaling);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), submenu);
settings = gtk_menu_item_new_with_mnemonic(_("_Settings"));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), settings);
submenu = gtk_menu_new();
showgrabkeydlg = gtk_menu_item_new_with_mnemonic(_("_Set grab keys"));
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), showgrabkeydlg);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings), submenu);
help = gtk_menu_item_new_with_mnemonic(_("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help);
submenu = gtk_menu_new();
about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), about);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), submenu);
#if GTK_CHECK_VERSION(3, 0, 0)
widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
widget = gtk_hbox_new(FALSE, 4);
#endif
status = gtk_image_new_from_icon_name("gtk-disconnect", GTK_ICON_SIZE_MENU);
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_widget_set_tooltip_text(status, _("Disconnected"));
#endif
gtk_box_pack_start(GTK_BOX(widget), status, FALSE, TRUE, 0);
statusbar = gtk_statusbar_new();
#if !GTK_CHECK_VERSION(3, 0, 0)
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(statusbar), TRUE);
#endif
gtk_box_pack_start(GTK_BOX(widget), statusbar, TRUE, TRUE, 0);
#if WITH_LIBVIEW
ViewAutoDrawer_SetActive(VIEW_AUTODRAWER(layout), FALSE);
ViewOvBox_SetOver(VIEW_OV_BOX(layout), menubar);
ViewOvBox_SetUnder(VIEW_OV_BOX(layout), vnc);
ViewOvBox_SetUnder(VIEW_OV_BOX(layout), widget);
#else
gtk_box_pack_start(GTK_BOX(layout), menubar, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(layout), vnc, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(layout), widget, FALSE, TRUE, 0);
#endif
gtk_container_add(GTK_CONTAINER(window), layout);
gtk_widget_realize(vnc);
g_value_init(&accel_setting, G_TYPE_STRING);
accels = gtk_accel_groups_from_object(G_OBJECT(window));
for ( ; accels ; accels = accels->next) {
accel_list = g_slist_append(accel_list, accels->data);
g_object_ref(G_OBJECT(accels->data));
}
#ifdef HAVE_GIOUNIX
if (strchr(args[0], '/')) {
GSocketAddress *addr = g_unix_socket_address_new_with_type
(args[0], strlen(args[0]),
G_UNIX_SOCKET_ADDRESS_PATH);
vnc_display_open_addr(VNC_DISPLAY(vnc), addr, NULL);
g_object_unref(addr);
} else {
#endif
if (g_str_equal(args[0], ""))
hostname = g_strdup("127.0.0.1");
else
hostname = g_strdup(args[0]);
tmp = strchr(hostname, ':');
if (tmp) {
*tmp = '\0';
port = g_strdup_printf("%d", 5900 + atoi(tmp + 1));
} else {
port = g_strdup("5900");
}
vnc_display_open_host(VNC_DISPLAY(vnc), hostname, port);
g_free(hostname);
g_free(port);
#ifdef HAVE_GIOUNIX
}
#endif
vnc_display_set_keyboard_grab(VNC_DISPLAY(vnc), TRUE);
vnc_display_set_pointer_grab(VNC_DISPLAY(vnc), TRUE);
vnc_display_set_pointer_local(VNC_DISPLAY(vnc), TRUE);
if (!gtk_widget_is_composited(window)) {
vnc_display_set_scaling(VNC_DISPLAY(vnc), TRUE);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(scaling), TRUE);
}
g_signal_connect(window, "delete-event",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(vnc, "vnc-connected",
G_CALLBACK(vnc_connected), NULL);
g_signal_connect(vnc, "vnc-initialized",
G_CALLBACK(vnc_initialized), window);
g_signal_connect(vnc, "vnc-disconnected",
G_CALLBACK(vnc_disconnected), window);
g_signal_connect(vnc, "vnc-auth-credential",
G_CALLBACK(vnc_credential), NULL);
g_signal_connect(vnc, "vnc-auth-failure",
G_CALLBACK(vnc_auth_failure), NULL);
g_signal_connect(vnc, "vnc-desktop-resize",
G_CALLBACK(vnc_desktop_resize), NULL);
g_signal_connect(vnc, "vnc-pointer-grab",
G_CALLBACK(vnc_mouse_grab), window);
g_signal_connect(vnc, "vnc-pointer-ungrab",
G_CALLBACK(vnc_mouse_ungrab), window);
g_signal_connect(vnc, "vnc-keyboard-grab",
G_CALLBACK(vnc_key_grab), window);
g_signal_connect(vnc, "vnc-keyboard-ungrab",
G_CALLBACK(vnc_key_ungrab), window);
g_signal_connect(screenshot, "activate",
G_CALLBACK(vnc_screenshot), vnc);
g_signal_connect(close, "activate",
G_CALLBACK(gtk_main_quit), vnc);
g_signal_connect(caf1, "activate",
G_CALLBACK(send_caf1), vnc);
g_signal_connect(caf2, "activate",
G_CALLBACK(send_caf2), vnc);
g_signal_connect(caf3, "activate",
G_CALLBACK(send_caf3), vnc);
g_signal_connect(caf4, "activate",
G_CALLBACK(send_caf4), vnc);
g_signal_connect(caf5, "activate",
G_CALLBACK(send_caf5), vnc);
g_signal_connect(caf6, "activate",
G_CALLBACK(send_caf6), vnc);
g_signal_connect(caf7, "activate",
G_CALLBACK(send_caf7), vnc);
g_signal_connect(caf8, "activate",
G_CALLBACK(send_caf8), vnc);
g_signal_connect(cad, "activate",
G_CALLBACK(send_cad), vnc);
g_signal_connect(cab, "activate",
G_CALLBACK(send_cab), vnc);
g_signal_connect(showgrabkeydlg, "activate",
G_CALLBACK(do_set_grab_keys), window);
g_signal_connect(fullscreen, "toggled",
G_CALLBACK(do_fullscreen), window);
g_signal_connect(scaling, "toggled",
G_CALLBACK(do_scaling), vnc);
g_signal_connect(about, "activate",
G_CALLBACK(do_about), window);
#if WITH_LIBVIEW
g_signal_connect(window, "window-state-event",
G_CALLBACK(window_state_event), layout);
#endif
return 0;
}
/*
* Local variables:
* c-indent-level: 4
* c-basic-offset: 4
* indent-tabs-mode: nil
* End:
*/