pxcloud/virt-viewer
5
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/virt-viewer synced 2025-12-30 18:31:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove circular dependancy between VirtViewerDisplay and VirtViewer

Browse Source 
Add many signals to VirtViewerDisplay which are emitted when various
events occur. This lets us remove all the code in the VirtViewerDisplay
subclasses which call back into VirtViewer methods. Instead VirtViewer
can simply connect signals to the display
This commit is contained in:
Daniel P. Berrange 2011-07-11 15:35:47 +01:00
parent 7a7112a9fa
commit 4ba39d0224
9 changed files with 544 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
src/virt-viewer-display-spice.c
View File

@ -24,6 +24,8 @@
#include <spice-audio.h>
#include <glib/gi18n.h>
#include "virt-viewer-util.h"
#include "virt-viewer-display-spice.h"
#include "virt-viewer-auth.h"
@ -148,11 +150,7 @@ virt_viewer_display_spice_channel_open_fd_request(SpiceChannel *channel,
gint tls G_GNUC_UNUSED,
VirtViewerDisplay *display)
{
VirtViewerDisplaySpice *self = VIRT_VIEWER_DISPLAY_SPICE(display);
g_return_if_fail(self != NULL);
virt_viewer_channel_open_fd(display->viewer, (VirtViewerDisplayChannel *)channel);
g_signal_emit_by_name(display, "display-channel-open", channel);
}
static void
@ -164,7 +162,6 @@ virt_viewer_display_spice_main_channel_event(SpiceChannel *channel G_GNUC_UNUSED
char *password = NULL;
g_return_if_fail(self != NULL);
g_return_if_fail(display->viewer != NULL);
switch (event) {
case SPICE_CHANNEL_OPENED:
@ -172,19 +169,20 @@ virt_viewer_display_spice_main_channel_event(SpiceChannel *channel G_GNUC_UNUSED
break;
case SPICE_CHANNEL_CLOSED:
DEBUG_LOG("main channel: closed");
virt_viewer_quit(display->viewer);
g_signal_emit_by_name(display, "display-disconnected");
break;
case SPICE_CHANNEL_ERROR_CONNECT:
DEBUG_LOG("main channel: failed to connect");
virt_viewer_disconnected(display->viewer);
g_signal_emit_by_name(display, "display-disconnected");
break;
case SPICE_CHANNEL_ERROR_AUTH:
DEBUG_LOG("main channel: auth failure (wrong password?)");
int ret = virt_viewer_auth_collect_credentials("SPICE",
display->viewer->pretty_address,
NULL,
NULL, &password);
if (ret < 0) {
virt_viewer_quit(display->viewer);
g_signal_emit_by_name(display, "display-auth-refused",
_("Unable to collect credentials"));
} else {
g_object_set(self->session, "password", password, NULL);
spice_session_connect(self->session);
@ -192,7 +190,7 @@ virt_viewer_display_spice_main_channel_event(SpiceChannel *channel G_GNUC_UNUSED
break;
default:
g_warning("unknown main channel event: %d", event);
virt_viewer_disconnected(display->viewer);
g_signal_emit_by_name(display, "display-disconnected");
break;
}
@ -207,21 +205,20 @@ virt_viewer_display_spice_main_channel_event(SpiceChannel *channel G_GNUC_UNUSED
* recalculation of the display within existing window size
*/
static void
virt_viewer_display_spice_resize_desktop(SpiceChannel *channel G_GNUC_UNUSED,
virt_viewer_display_spice_primary_create(SpiceChannel *channel G_GNUC_UNUSED,
gint format G_GNUC_UNUSED,
gint width,
gint height,
gint stride G_GNUC_UNUSED,
gint shmid G_GNUC_UNUSED,
gpointer imgdata G_GNUC_UNUSED,
VirtViewer *viewer)
VirtViewerDisplay *display)
{
DEBUG_LOG("desktop resize %dx%d", width, height);
virt_viewer_display_set_desktop_size(VIRT_VIEWER_DISPLAY(viewer->display), width, height);
if (viewer->autoResize && viewer->window && !viewer->fullscreen)
virt_viewer_resize_main_window(viewer);
virt_viewer_display_set_desktop_size(display, width, height);
g_signal_emit_by_name(display, "display-initialized");
g_signal_emit_by_name(display, "display-desktop-resize");
}
@ -248,7 +245,7 @@ virt_viewer_display_spice_channel_new(SpiceSession *s,
if (SPICE_IS_DISPLAY_CHANNEL(channel)) {
DEBUG_LOG("new display channel (#%d)", id);
g_signal_connect(channel, "display-primary-create",
G_CALLBACK(virt_viewer_display_spice_resize_desktop), display->viewer);
G_CALLBACK(virt_viewer_display_spice_primary_create), display);
self->display = spice_display_new(s, id);
gtk_container_add(GTK_CONTAINER(self), GTK_WIDGET(self->display));
@ -261,7 +258,7 @@ virt_viewer_display_spice_channel_new(SpiceSession *s,
"auto-clipboard", TRUE,
NULL);
virt_viewer_initialized(display->viewer);
g_signal_emit_by_name(display, "display-connected");
}
if (SPICE_IS_INPUTS_CHANNEL(channel)) {
@ -303,16 +300,11 @@ virt_viewer_display_spice_channel_destroy(G_GNUC_UNUSED SpiceSession *s,
}
GtkWidget *
virt_viewer_display_spice_new(VirtViewer *viewer)
virt_viewer_display_spice_new(void)
{
VirtViewerDisplaySpice *self;
VirtViewerDisplay *d;
g_return_val_if_fail(viewer != NULL, NULL);
self = g_object_new(VIRT_VIEWER_TYPE_DISPLAY_SPICE, NULL);
d = VIRT_VIEWER_DISPLAY(self);
d->viewer = viewer;
self->session = spice_session_new();
g_signal_connect(self->session, "channel-new",

2
src/virt-viewer-display-spice.h
View File

@ -63,7 +63,7 @@ typedef struct {
GType virt_viewer_display_spice_get_type(void);
GtkWidget* virt_viewer_display_spice_new(VirtViewer *viewer);
GtkWidget* virt_viewer_display_spice_new(void);
G_END_DECLS

201
src/virt-viewer-display-vnc.c
View File

@ -25,7 +25,9 @@
#include "virt-viewer-auth.h"
#include "virt-viewer-display-vnc.h"
G_DEFINE_TYPE(VirtViewerDisplayVNC, virt_viewer_display_vnc, VIRT_VIEWER_TYPE_DISPLAY)
#include <glib/gi18n.h>
G_DEFINE_TYPE(VirtViewerDisplayVnc, virt_viewer_display_vnc, VIRT_VIEWER_TYPE_DISPLAY)
static void virt_viewer_display_vnc_close(VirtViewerDisplay* display);
static void virt_viewer_display_vnc_send_keys(VirtViewerDisplay* display, const guint *keyvals, int nkeyvals);
@ -36,7 +38,7 @@ static gboolean virt_viewer_display_vnc_channel_open_fd(VirtViewerDisplay* displ
VirtViewerDisplayChannel* channel, int fd);
static void
virt_viewer_display_vnc_class_init(VirtViewerDisplayVNCClass *klass)
virt_viewer_display_vnc_class_init(VirtViewerDisplayVncClass *klass)
{
VirtViewerDisplayClass *dclass = VIRT_VIEWER_DISPLAY_CLASS(klass);
@ -49,36 +51,66 @@ virt_viewer_display_vnc_class_init(VirtViewerDisplayVNCClass *klass)
}
static void
virt_viewer_display_vnc_init(VirtViewerDisplayVNC *self G_GNUC_UNUSED)
virt_viewer_display_vnc_init(VirtViewerDisplayVnc *self G_GNUC_UNUSED)
{
}
static void
virt_viewer_display_vnc_mouse_grab(GtkWidget *vnc G_GNUC_UNUSED,
VirtViewerDisplayVNC *self)
virt_viewer_display_vnc_connected(VncDisplay *vnc G_GNUC_UNUSED,
VirtViewerDisplay *display)
{
virt_viewer_set_title(VIRT_VIEWER_DISPLAY(self)->viewer, TRUE);
g_signal_emit_by_name(display, "display-connected");
}
static void
virt_viewer_display_vnc_mouse_ungrab(GtkWidget *vnc G_GNUC_UNUSED,
VirtViewerDisplayVNC *self)
virt_viewer_display_vnc_disconnected(VncDisplay *vnc G_GNUC_UNUSED,
VirtViewerDisplay *display)
{
virt_viewer_set_title(VIRT_VIEWER_DISPLAY(self)->viewer, FALSE);
g_signal_emit_by_name(display, "display-disconnected");
}
static void
virt_viewer_display_vnc_key_grab(GtkWidget *vnc G_GNUC_UNUSED,
VirtViewerDisplayVNC *self)
virt_viewer_display_vnc_initialized(VncDisplay *vnc G_GNUC_UNUSED,
VirtViewerDisplay *display)
{
virt_viewer_disable_modifiers(VIRT_VIEWER_DISPLAY(self)->viewer);
g_signal_emit_by_name(display, "display-initialized");
}
static void
virt_viewer_display_vnc_key_ungrab(GtkWidget *vnc G_GNUC_UNUSED,
VirtViewerDisplayVNC *self)
virt_viewer_display_vnc_cut_text(VncDisplay *vnc G_GNUC_UNUSED,
const char *text,
VirtViewerDisplay *display)
{
virt_viewer_enable_modifiers(VIRT_VIEWER_DISPLAY(self)->viewer);
g_signal_emit_by_name(display, "display-cut-text", text);
}
static void
virt_viewer_display_vnc_mouse_grab(VncDisplay *vnc G_GNUC_UNUSED,
VirtViewerDisplay *display)
{
g_signal_emit_by_name(display, "display-pointer-grab");
}
static void
virt_viewer_display_vnc_mouse_ungrab(VncDisplay *vnc G_GNUC_UNUSED,
VirtViewerDisplay *display)
{
g_signal_emit_by_name(display, "display-pointer-ungrab");
}
static void
virt_viewer_display_vnc_key_grab(VncDisplay *vnc G_GNUC_UNUSED,
VirtViewerDisplay *display)
{
g_signal_emit_by_name(display, "display-keyboard-grab");
}
static void
virt_viewer_display_vnc_key_ungrab(VncDisplay *vnc G_GNUC_UNUSED,
VirtViewerDisplay *display)
{
g_signal_emit_by_name(display, "display-keyboard-ungrab");
}
static void
@ -86,7 +118,7 @@ virt_viewer_display_vnc_send_keys(VirtViewerDisplay* display,
const guint *keyvals,
int nkeyvals)
{
VirtViewerDisplayVNC *self = VIRT_VIEWER_DISPLAY_VNC(display);
VirtViewerDisplayVnc *self = VIRT_VIEWER_DISPLAY_VNC(display);
g_return_if_fail(self != NULL);
g_return_if_fail(keyvals != NULL);
@ -98,7 +130,7 @@ virt_viewer_display_vnc_send_keys(VirtViewerDisplay* display,
static GdkPixbuf*
virt_viewer_display_vnc_get_pixbuf(VirtViewerDisplay* display)
{
VirtViewerDisplayVNC *self = VIRT_VIEWER_DISPLAY_VNC(display);
VirtViewerDisplayVnc *self = VIRT_VIEWER_DISPLAY_VNC(display);
g_return_val_if_fail(self != NULL, NULL);
g_return_val_if_fail(self->vnc != NULL, NULL);
@ -110,7 +142,7 @@ static gboolean
virt_viewer_display_vnc_open_fd(VirtViewerDisplay* display,
int fd)
{
VirtViewerDisplayVNC *self = VIRT_VIEWER_DISPLAY_VNC(display);
VirtViewerDisplayVnc *self = VIRT_VIEWER_DISPLAY_VNC(display);
g_return_val_if_fail(self != NULL, FALSE);
g_return_val_if_fail(self->vnc != NULL, FALSE);
@ -132,7 +164,7 @@ virt_viewer_display_vnc_open_host(VirtViewerDisplay* display,
char *host,
char *port)
{
VirtViewerDisplayVNC *self = VIRT_VIEWER_DISPLAY_VNC(display);
VirtViewerDisplayVnc *self = VIRT_VIEWER_DISPLAY_VNC(display);
g_return_val_if_fail(self != NULL, FALSE);
g_return_val_if_fail(self->vnc != NULL, FALSE);
@ -143,7 +175,7 @@ virt_viewer_display_vnc_open_host(VirtViewerDisplay* display,
static void
virt_viewer_display_vnc_close(VirtViewerDisplay* display)
{
VirtViewerDisplayVNC *self = VIRT_VIEWER_DISPLAY_VNC(display);
VirtViewerDisplayVnc *self = VIRT_VIEWER_DISPLAY_VNC(display);
g_return_if_fail(self != NULL);
@ -152,48 +184,30 @@ virt_viewer_display_vnc_close(VirtViewerDisplay* display)
}
static void
virt_viewer_display_vnc_bell(VirtViewer *viewer,
gpointer data G_GNUC_UNUSED)
virt_viewer_display_vnc_bell(VncDisplay *vnc G_GNUC_UNUSED,
VirtViewerDisplay *display)
{
gdk_window_beep(gtk_widget_get_window(GTK_WIDGET(viewer->window)));
g_signal_emit_by_name(display, "display-bell");
}
static void
virt_viewer_display_vnc_auth_unsupported(VirtViewer *viewer,
virt_viewer_display_vnc_auth_unsupported(VncDisplay *vnc G_GNUC_UNUSED,
unsigned int authType,
gpointer data G_GNUC_UNUSED)
VirtViewerDisplay *display)
{
virt_viewer_simple_message_dialog(viewer->window,
_("Unable to authenticate with VNC server at %s\n"
"Unsupported authentication type %d"),
viewer->pretty_address, authType);
char *msg = g_strdup_printf(_("Unsupported authentication type %d"),
authType);
g_signal_emit_by_name(display, "display-auth-failed", msg);
g_free(msg);
}
static void
virt_viewer_display_vnc_auth_failure(VirtViewer *viewer,
virt_viewer_display_vnc_auth_failure(VncDisplay *vnc G_GNUC_UNUSED,
const char *reason,
gpointer data G_GNUC_UNUSED)
VirtViewerDisplay *display)
{
GtkWidget *dialog;
int ret;
dialog = gtk_message_dialog_new(GTK_WINDOW(viewer->window),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_YES_NO,
_("Unable to authenticate with VNC server at %s: %s\n"
"Retry connection again?"),
viewer->pretty_address, reason);
ret = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
if (ret == GTK_RESPONSE_YES)
viewer->authretry = TRUE;
else
viewer->authretry = FALSE;
g_signal_emit_by_name(display, "display-auth-refused", reason);
}
/*
@ -203,33 +217,28 @@ virt_viewer_display_vnc_auth_failure(VirtViewer *viewer,
* recalculation of the display within existing window size
*/
static void
virt_viewer_display_vnc_resize_desktop(VirtViewer *viewer, gint width, gint height)
virt_viewer_display_vnc_resize_desktop(VncDisplay *vnc G_GNUC_UNUSED,
int width, int height,
VirtViewerDisplay *display)
{
DEBUG_LOG("desktop resize %dx%d", width, height);
virt_viewer_display_set_desktop_size(VIRT_VIEWER_DISPLAY(viewer->display), width, height);
if (viewer->autoResize && viewer->window && !viewer->fullscreen)
virt_viewer_resize_main_window(viewer);
virt_viewer_display_set_desktop_size(display, width, height);
g_signal_emit_by_name(display, "display-desktop-resize");
}
GtkWidget *
virt_viewer_display_vnc_new(VirtViewer *viewer)
virt_viewer_display_vnc_new(void)
{
VirtViewerDisplayVNC *self;
VirtViewerDisplay *d;
VirtViewerDisplayVnc *display;
g_return_val_if_fail(viewer != NULL, NULL);
display = g_object_new(VIRT_VIEWER_TYPE_DISPLAY_VNC, NULL);
self = g_object_new(VIRT_VIEWER_TYPE_DISPLAY_VNC, NULL);
d = VIRT_VIEWER_DISPLAY(self);
d->viewer = viewer;
self->vnc = VNC_DISPLAY(vnc_display_new());
gtk_container_add(GTK_CONTAINER(self), GTK_WIDGET(self->vnc));
vnc_display_set_keyboard_grab(self->vnc, TRUE);
vnc_display_set_pointer_grab(self->vnc, TRUE);
display->vnc = VNC_DISPLAY(vnc_display_new());
gtk_container_add(GTK_CONTAINER(display), GTK_WIDGET(display->vnc));
vnc_display_set_keyboard_grab(display->vnc, TRUE);
vnc_display_set_pointer_grab(display->vnc, TRUE);
/*
* In auto-resize mode we have things setup so that we always
@ -240,41 +249,41 @@ virt_viewer_display_vnc_new(VirtViewer *viewer)
* We disable force_size because we want to allow user to
* manually size the widget smaller too
*/
vnc_display_set_force_size(self->vnc, FALSE);
vnc_display_set_scaling(self->vnc, TRUE);
vnc_display_set_force_size(display->vnc, FALSE);
vnc_display_set_scaling(display->vnc, TRUE);
g_signal_connect_swapped(self->vnc, "vnc-connected",
G_CALLBACK(virt_viewer_connected), viewer);
g_signal_connect_swapped(self->vnc, "vnc-initialized",
G_CALLBACK(virt_viewer_initialized), viewer);
g_signal_connect_swapped(self->vnc, "vnc-disconnected",
G_CALLBACK(virt_viewer_disconnected), viewer);
g_signal_connect(display->vnc, "vnc-connected",
G_CALLBACK(virt_viewer_display_vnc_connected), display);
g_signal_connect(display->vnc, "vnc-initialized",
G_CALLBACK(virt_viewer_display_vnc_initialized), display);
g_signal_connect(display->vnc, "vnc-disconnected",
G_CALLBACK(virt_viewer_display_vnc_disconnected), display);
/* When VNC desktop resizes, we have to resize the containing widget */
g_signal_connect_swapped(self->vnc, "vnc-desktop-resize",
G_CALLBACK(virt_viewer_display_vnc_resize_desktop), viewer);
g_signal_connect_swapped(self->vnc, "vnc-bell",
G_CALLBACK(virt_viewer_display_vnc_bell), NULL);
g_signal_connect_swapped(self->vnc, "vnc-auth-failure",
G_CALLBACK(virt_viewer_display_vnc_auth_failure), viewer);
g_signal_connect_swapped(self->vnc, "vnc-auth-unsupported",
G_CALLBACK(virt_viewer_display_vnc_auth_unsupported), viewer);
g_signal_connect_swapped(self->vnc, "vnc-server-cut-text",
G_CALLBACK(virt_viewer_server_cut_text), viewer);
g_signal_connect(display->vnc, "vnc-desktop-resize",
G_CALLBACK(virt_viewer_display_vnc_resize_desktop), display);
g_signal_connect(display->vnc, "vnc-bell",
G_CALLBACK(virt_viewer_display_vnc_bell), display);
g_signal_connect(display->vnc, "vnc-auth-failure",
G_CALLBACK(virt_viewer_display_vnc_auth_failure), display);
g_signal_connect(display->vnc, "vnc-auth-unsupported",
G_CALLBACK(virt_viewer_display_vnc_auth_unsupported), display);
g_signal_connect(display->vnc, "vnc-server-cut-text",
G_CALLBACK(virt_viewer_display_vnc_cut_text), display);
g_signal_connect(self->vnc, "vnc-pointer-grab",
G_CALLBACK(virt_viewer_display_vnc_mouse_grab), self);
g_signal_connect(self->vnc, "vnc-pointer-ungrab",
G_CALLBACK(virt_viewer_display_vnc_mouse_ungrab), self);
g_signal_connect(self->vnc, "vnc-keyboard-grab",
G_CALLBACK(virt_viewer_display_vnc_key_grab), self);
g_signal_connect(self->vnc, "vnc-keyboard-ungrab",
G_CALLBACK(virt_viewer_display_vnc_key_ungrab), self);
g_signal_connect(display->vnc, "vnc-pointer-grab",
G_CALLBACK(virt_viewer_display_vnc_mouse_grab), display);
g_signal_connect(display->vnc, "vnc-pointer-ungrab",
G_CALLBACK(virt_viewer_display_vnc_mouse_ungrab), display);
g_signal_connect(display->vnc, "vnc-keyboard-grab",
G_CALLBACK(virt_viewer_display_vnc_key_grab), display);
g_signal_connect(display->vnc, "vnc-keyboard-ungrab",
G_CALLBACK(virt_viewer_display_vnc_key_ungrab), display);
g_signal_connect(self->vnc, "vnc-auth-credential",
G_CALLBACK(virt_viewer_auth_vnc_credentials), &viewer->pretty_address);
g_signal_connect(display->vnc, "vnc-auth-credential",
G_CALLBACK(virt_viewer_auth_vnc_credentials), NULL);
return GTK_WIDGET(self);
return GTK_WIDGET(display);
}

12
src/virt-viewer-display-vnc.h
View File

@ -34,10 +34,10 @@ G_BEGIN_DECLS
#define VIRT_VIEWER_TYPE_DISPLAY_VNC virt_viewer_display_vnc_get_type()
#define VIRT_VIEWER_DISPLAY_VNC(obj) \
(G_TYPE_CHECK_INSTANCE_CAST ((obj), VIRT_VIEWER_TYPE_DISPLAY_VNC, VirtViewerDisplayVNC))
(G_TYPE_CHECK_INSTANCE_CAST ((obj), VIRT_VIEWER_TYPE_DISPLAY_VNC, VirtViewerDisplayVnc))
#define VIRT_VIEWER_DISPLAY_VNC_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST ((klass), VIRT_VIEWER_TYPE_DISPLAY_VNC, VirtViewerDisplayVNCClass))
(G_TYPE_CHECK_CLASS_CAST ((klass), VIRT_VIEWER_TYPE_DISPLAY_VNC, VirtViewerDisplayVncClass))
#define VIRT_IS_VIEWER_DISPLAY_VNC(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIRT_VIEWER_TYPE_DISPLAY_VNC))
@ -46,21 +46,21 @@ G_BEGIN_DECLS
(G_TYPE_CHECK_CLASS_TYPE ((klass), VIRT_VIEWER_TYPE_DISPLAY_VNC))
#define VIRT_VIEWER_DISPLAY_VNC_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS ((obj), VIRT_VIEWER_TYPE_DISPLAY_VNC, VirtViewerDisplayVNCClass))
(G_TYPE_INSTANCE_GET_CLASS ((obj), VIRT_VIEWER_TYPE_DISPLAY_VNC, VirtViewerDisplayVncClass))
typedef struct {
VirtViewerDisplay parent;
VncDisplay *vnc;
} VirtViewerDisplayVNC;
} VirtViewerDisplayVnc;
typedef struct {
VirtViewerDisplayClass parent_class;
} VirtViewerDisplayVNCClass;
} VirtViewerDisplayVncClass;
GType virt_viewer_display_vnc_get_type(void);
GtkWidget* virt_viewer_display_vnc_new(VirtViewer *viewer);
GtkWidget* virt_viewer_display_vnc_new(void);
G_END_DECLS

154
src/virt-viewer-display.c
View File

@ -75,14 +75,11 @@ enum {
static void
virt_viewer_display_class_init(VirtViewerDisplayClass *class)
{
GObjectClass *gobject_class;
GtkWidgetClass *widget_class;
GObjectClass *object_class = G_OBJECT_CLASS(class);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(class);
gobject_class = (GObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
gobject_class->set_property = virt_viewer_display_set_property;
gobject_class->get_property = virt_viewer_display_get_property;
object_class->set_property = virt_viewer_display_set_property;
object_class->get_property = virt_viewer_display_get_property;
#if GTK_CHECK_VERSION(3, 0, 0)
widget_class->get_preferred_width = virt_viewer_display_get_preferred_width;
@ -92,7 +89,7 @@ virt_viewer_display_class_init(VirtViewerDisplayClass *class)
#endif
widget_class->size_allocate = virt_viewer_display_size_allocate;
g_object_class_install_property(gobject_class,
g_object_class_install_property(object_class,
PROP_DESKTOP_WIDTH,
g_param_spec_int("desktop-width",
"Width",
@ -101,7 +98,7 @@ virt_viewer_display_class_init(VirtViewerDisplayClass *class)
G_MAXINT32,
100,
G_PARAM_READWRITE));
g_object_class_install_property(gobject_class,
g_object_class_install_property(object_class,
PROP_DESKTOP_HEIGHT,
g_param_spec_int("desktop-height",
"Height",
@ -110,14 +107,14 @@ virt_viewer_display_class_init(VirtViewerDisplayClass *class)
G_MAXINT32,
100,
G_PARAM_READWRITE));
g_object_class_install_property(gobject_class,
g_object_class_install_property(object_class,
PROP_ZOOM,
g_param_spec_boolean("zoom",
"Zoom",
"Zoom",
TRUE,
G_PARAM_READWRITE));
g_object_class_install_property(gobject_class,
g_object_class_install_property(object_class,
PROP_ZOOM_LEVEL,
g_param_spec_int("zoom-level",
"Zoom",
@ -127,7 +124,138 @@ virt_viewer_display_class_init(VirtViewerDisplayClass *class)
100,
G_PARAM_READWRITE));
g_type_class_add_private(gobject_class, sizeof(VirtViewerDisplayPrivate));
g_signal_new("display-connected",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_connected),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("display-initialized",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_initialized),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("display-disconnected",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_disconnected),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("display-channel-open",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_channel_open),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
G_TYPE_OBJECT);
g_signal_new("display-auth-refused",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_auth_refused),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
g_signal_new("display-auth-failed",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_auth_failed),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
g_signal_new("display-pointer-grab",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_pointer_grab),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("display-pointer-ungrab",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_pointer_ungrab),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("display-keyboard-grab",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_keyboard_grab),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("display-keyboard-ungrab",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_keyboard_ungrab),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("display-desktop-resize",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_desktop_resize),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_signal_new("display-cut-text",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_cut_text),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
g_signal_new("display-bell",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET(VirtViewerDisplayClass, display_bell),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
g_type_class_add_private(object_class, sizeof(VirtViewerDisplayPrivate));
}
static void
@ -147,7 +275,7 @@ virt_viewer_display_init(VirtViewerDisplay *display)
GtkWidget*
virt_viewer_display_new(void)
{
return g_object_new (VIRT_VIEWER_TYPE_DISPLAY, NULL);
return g_object_new(VIRT_VIEWER_TYPE_DISPLAY, NULL);
}
static void

28
src/virt-viewer-display.h
View File

@ -26,8 +26,6 @@
#include <gtk/gtk.h>
#include "virt-viewer-priv.h"
G_BEGIN_DECLS
#define VIRT_VIEWER_TYPE_DISPLAY virt_viewer_display_get_type()
@ -51,13 +49,13 @@ typedef struct _VirtViewerDisplay VirtViewerDisplay;
typedef struct _VirtViewerDisplayClass VirtViewerDisplayClass;
typedef struct _VirtViewerDisplayPrivate VirtViewerDisplayPrivate;
typedef struct _VirtViewerDisplayChannel VirtViewerDisplayChannel;
/* perhaps this become an interface, and be pushed in gtkvnc and spice? */
struct _VirtViewerDisplay {
GtkBin parent;
VirtViewer *viewer;
VirtViewerDisplayPrivate *priv;
};
@ -71,8 +69,26 @@ struct _VirtViewerDisplayClass {
GdkPixbuf* (* get_pixbuf) (VirtViewerDisplay* display);
gboolean (* open_fd) (VirtViewerDisplay* display, int fd);
gboolean (* open_host) (VirtViewerDisplay* display, char *host, char *port);
gboolean (* channel_open_fd) (VirtViewerDisplay* display,
VirtViewerDisplayChannel* channel, int fd);
gboolean (* channel_open_fd) (VirtViewerDisplay* display, VirtViewerDisplayChannel *channel, int fd);
/* signals */
void (*display_connected)(VirtViewerDisplay *display);
void (*display_initialized)(VirtViewerDisplay *display);
void (*display_disconnected)(VirtViewerDisplay *display);
void (*display_auth_refused)(VirtViewerDisplay *display, const char *msg);
void (*display_auth_failed)(VirtViewerDisplay *display, const char *msg);
void (*display_channel_open)(VirtViewerDisplay *display, VirtViewerDisplayChannel *channel);
void (*display_pointer_grab)(VirtViewerDisplay *display);
void (*display_pointer_ungrab)(VirtViewerDisplay *display);
void (*display_keyboard_grab)(VirtViewerDisplay *display);
void (*display_keyboard_ungrab)(VirtViewerDisplay *display);
void (*display_desktop_resize)(VirtViewerDisplay *display);
void (*display_cut_text)(VirtViewerDisplay *display, const char *str);
void (*display_bell)(VirtViewerDisplay *display);
};
GType virt_viewer_display_get_type(void);

129
src/virt-viewer-priv.h
View File

@ -1,129 +0,0 @@
/*
* Virt Viewer: A virtual machine console viewer
*
* Copyright (C) 2007-2009 Red Hat,
* Copyright (C) 2009 Daniel P. Berrange
* Copyright (C) 2010 Marc-André Lureau
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#ifndef _VIRT_VIEWER_PRIV_H
# define _VIRT_VIEWER_PRIV_H
#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include <libvirt/libvirt.h>
#include <libvirt/virterror.h>
#include <libxml/xpath.h>
#include <libxml/uri.h>
typedef struct _VirtViewerDisplay VirtViewerDisplay;
typedef struct _VirtViewerDisplayClass VirtViewerDisplayClass;
typedef struct _VirtViewer VirtViewer;
typedef struct _VirtViewerSize VirtViewerSize;
typedef struct _VirtViewerDisplayChanne VirtViewerDisplayChannel;
enum menuNums {
FILE_MENU,
VIEW_MENU,
SEND_KEY_MENU,
HELP_MENU,
LAST_MENU // sentinel
};
struct _VirtViewer {
char *uri;
virConnectPtr conn;
char *domkey;
char *domtitle;
GtkBuilder *builder;
GtkWidget *window;
GtkWidget *container;
GtkWidget *notebook;
GtkWidget *status;
GtkWidget *toolbar;
GtkWidget *layout;
char *pretty_address;
gboolean autoResize;
gboolean fullscreen;
gboolean withEvents;
gboolean active;
gboolean accelEnabled;
GValue accelSetting;
GSList *accelList;
int accelMenuSig[LAST_MENU];
gboolean waitvm;
gboolean reconnect;
gboolean direct;
gboolean verbose;
gboolean authretry;
gboolean connected;
gchar *clipboard;
GtkWidget *display;
gint zoomlevel;
char *unixsock;
char *ghost;
char *gport;
char *host;
char *transport;
char *user;
int port;
};
struct _VirtViewerSize {
VirtViewer *viewer;
gint width, height;
gulong sig_id;
gulong sig_id_h;
gulong sig_id_w;
};
void virt_viewer_connected(VirtViewer *viewer);
void virt_viewer_initialized(VirtViewer *viewer);
void virt_viewer_disconnected(VirtViewer *viewer);
void virt_viewer_set_status(VirtViewer *viewer, const char *text);
void virt_viewer_set_title(VirtViewer *viewer, gboolean grabbed);
void virt_viewer_enable_modifiers(VirtViewer *viewer);
void virt_viewer_disable_modifiers(VirtViewer *viewer);
void virt_viewer_server_cut_text(VirtViewer *viewer, const gchar *text);
void virt_viewer_resize_main_window(VirtViewer *viewer);
void virt_viewer_channel_open_fd(VirtViewer *viewer, VirtViewerDisplayChannel *channel);
void virt_viewer_quit(VirtViewer *viewer);
void virt_viewer_simple_message_dialog(GtkWidget *window, const char *fmt, ...);
#endif // _VIRT_VIEWER_PRIV_H
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* tab-width: 8
* End:
*/

276
src/virt-viewer.c
View File

@ -25,6 +25,7 @@
#include <config.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
@ -32,6 +33,13 @@
#include <unistd.h>
#include <locale.h>
#include <glib/gprintf.h>
#include <glib/gi18n.h>
#include <libvirt/libvirt.h>
#include <libvirt/virterror.h>
#include <libxml/xpath.h>
#include <libxml/uri.h>
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
@ -46,7 +54,6 @@
#endif
#include "virt-viewer.h"
#include "virt-viewer-priv.h"
#include "virt-viewer-events.h"
#include "virt-viewer-auth.h"
#include "virt-viewer-display-vnc.h"
@ -75,9 +82,38 @@ void virt_viewer_menu_file_screenshot(GtkWidget *menu, VirtViewer *viewer);
void virt_viewer_about_close(GtkWidget *dialog, VirtViewer *viewer);
void virt_viewer_about_delete(GtkWidget *dialog, void *dummy, VirtViewer *viewer);
static const char * const menuNames[LAST_MENU] = {
"menu-file", "menu-view", "menu-send", "menu-help"
};
/* Internal methods */
static void virt_viewer_connected(VirtViewerDisplay *display,
VirtViewer *viewer);
static void virt_viewer_initialized(VirtViewerDisplay *display,
VirtViewer *viewer);
static void virt_viewer_disconnected(VirtViewerDisplay *display,
VirtViewer *viewer);
static void virt_viewer_auth_refused(VirtViewerDisplay *display,
const char *msg,
VirtViewer *viewer);
static void virt_viewer_auth_failed(VirtViewerDisplay *display,
const char *msg,
VirtViewer *viewer);
static void virt_viewer_server_cut_text(VirtViewerDisplay *display,
const gchar *text,
VirtViewer *viewer);
static void virt_viewer_bell(VirtViewerDisplay *display,
VirtViewer *viewer);
static void virt_viewer_enable_modifiers(VirtViewer *viewer);
static void virt_viewer_disable_modifiers(VirtViewer *viewer);
static void virt_viewer_resize_main_window(VirtViewer *viewer);
static void virt_viewer_set_status(VirtViewer *viewer, const char *text);
static void virt_viewer_set_title(VirtViewer *viewer, gboolean grabbed);
static void virt_viewer_channel_open(VirtViewerDisplay *display,
VirtViewerDisplayChannel *channel,
VirtViewer *viewer);
static void virt_viewer_quit(VirtViewer *viewer);
static void virt_viewer_simple_message_dialog(GtkWidget *window, const char *fmt, ...);
#if GTK_CHECK_VERSION(3, 0, 0)
@ -100,6 +136,70 @@ static const char * const menuNames[LAST_MENU] = {
#define GDK_F12 GDK_KEY_F12
#endif
enum menuNums {
FILE_MENU,
VIEW_MENU,
SEND_KEY_MENU,
HELP_MENU,
LAST_MENU // sentinel
};
struct _VirtViewer {
char *uri;
virConnectPtr conn;
char *domkey;
char *domtitle;
GtkBuilder *builder;
GtkWidget *window;
GtkWidget *container;
GtkWidget *notebook;
GtkWidget *status;
GtkWidget *toolbar;
GtkWidget *layout;
char *pretty_address;
gboolean autoResize;
gboolean fullscreen;
gboolean withEvents;
gboolean active;
gboolean accelEnabled;
GValue accelSetting;
GSList *accelList;
int accelMenuSig[LAST_MENU];
gboolean waitvm;
gboolean reconnect;
gboolean direct;
gboolean verbose;
gboolean authretry;
gboolean connected;
gchar *clipboard;
GtkWidget *display;
gint zoomlevel;
char *unixsock;
char *ghost;
char *gport;
char *host;
char *transport;
char *user;
int port;
};
static const char * const menuNames[LAST_MENU] = {
"menu-file", "menu-view", "menu-send", "menu-help"
};
#define MAX_KEY_COMBO 3
struct keyComboDef {
guint keys[MAX_KEY_COMBO];
@ -168,7 +268,7 @@ virt_viewer_simple_message_dialog(GtkWidget *window,
* isn't large enough that it goes as large as possible and lets the display
* scale down to fit, maintaining aspect ratio
*/
void
static void
virt_viewer_resize_main_window(VirtViewer *viewer)
{
GdkRectangle fullscreen;
@ -223,6 +323,15 @@ virt_viewer_resize_main_window(VirtViewer *viewer)
width, height);
}
static void
virt_viewer_desktop_resize(VirtViewerDisplay *display G_GNUC_UNUSED,
VirtViewer *viewer)
{
if (viewer->autoResize && viewer->window && !viewer->fullscreen)
virt_viewer_resize_main_window(viewer);
}
void
virt_viewer_menu_view_zoom_out(GtkWidget *menu G_GNUC_UNUSED,
VirtViewer *viewer)
@ -855,6 +964,35 @@ virt_viewer_show_display(VirtViewer *viewer)
gtk_notebook_set_current_page(GTK_NOTEBOOK(viewer->notebook), 1);
}
static void
virt_viewer_pointer_grab(VirtViewerDisplay *display G_GNUC_UNUSED,
VirtViewer *viewer)
{
virt_viewer_set_title(viewer, TRUE);
}
static void
virt_viewer_pointer_ungrab(VirtViewerDisplay *display G_GNUC_UNUSED,
VirtViewer *viewer)
{
virt_viewer_set_title(viewer, FALSE);
}
static void
virt_viewer_keyboard_grab(VirtViewerDisplay *display G_GNUC_UNUSED,
VirtViewer *viewer)
{
virt_viewer_disable_modifiers(viewer);
}
static void
virt_viewer_keyboard_ungrab(VirtViewerDisplay *display G_GNUC_UNUSED,
VirtViewer *viewer)
{
virt_viewer_enable_modifiers(viewer);
}
static void
virt_viewer_connect_info_free(VirtViewer *viewer)
{
@ -894,12 +1032,12 @@ virt_viewer_extract_connect_info(VirtViewer *viewer,
if (g_strcasecmp(type, "vnc") == 0) {
virt_viewer_trace(viewer, "Guest %s has a %s display\n",
viewer->domkey, type);
viewer->display = virt_viewer_display_vnc_new(viewer);
viewer->display = virt_viewer_display_vnc_new();
#ifdef HAVE_SPICE_GTK
} else if (g_strcasecmp(type, "spice") == 0) {
virt_viewer_trace(viewer, "Guest %s has a %s display\n",
viewer->domkey, type);
viewer->display = virt_viewer_display_spice_new(viewer);
viewer->display = virt_viewer_display_spice_new();
#endif
} else {
virt_viewer_trace(viewer, "Guest %s has unsupported %s display type\n",
@ -908,6 +1046,36 @@ virt_viewer_extract_connect_info(VirtViewer *viewer,
viewer->domkey);
goto cleanup;
}
g_signal_connect(viewer->display, "display-initialized",
G_CALLBACK(virt_viewer_initialized), viewer);
g_signal_connect(viewer->display, "display-connected",
G_CALLBACK(virt_viewer_connected), viewer);
g_signal_connect(viewer->display, "display-disconnected",
G_CALLBACK(virt_viewer_disconnected), viewer);
g_signal_connect(viewer->display, "display-channel-open",
G_CALLBACK(virt_viewer_channel_open), viewer);
g_signal_connect(viewer->display, "display-auth-refused",
G_CALLBACK(virt_viewer_auth_refused), viewer);
g_signal_connect(viewer->display, "display-auth-failed",
G_CALLBACK(virt_viewer_auth_failed), viewer);
g_signal_connect(viewer->display, "display-pointer-grab",
G_CALLBACK(virt_viewer_pointer_grab), viewer);
g_signal_connect(viewer->display, "display-pointer-ungrab",
G_CALLBACK(virt_viewer_pointer_ungrab), viewer);
g_signal_connect(viewer->display, "display-keyboard-grab",
G_CALLBACK(virt_viewer_keyboard_grab), viewer);
g_signal_connect(viewer->display, "display-keyboard-ungrab",
G_CALLBACK(virt_viewer_keyboard_ungrab), viewer);
g_signal_connect(viewer->display, "display-desktop-resize",
G_CALLBACK(virt_viewer_desktop_resize), viewer);
g_signal_connect(viewer->display, "display-cut-text",
G_CALLBACK(virt_viewer_server_cut_text), viewer);
g_signal_connect(viewer->display, "display-bell",
G_CALLBACK(virt_viewer_bell), viewer);
gtk_notebook_append_page(GTK_NOTEBOOK(viewer->notebook), viewer->display, NULL);
if (gtk_bin_get_child(GTK_BIN(viewer->display)))
gtk_widget_realize(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(viewer->display))));
@ -950,30 +1118,32 @@ cleanup:
}
#if defined(HAVE_SOCKETPAIR) && defined(HAVE_FORK)
void
virt_viewer_channel_open_fd(VirtViewer *viewer,
VirtViewerDisplayChannel *channel)
static void
virt_viewer_channel_open(VirtViewerDisplay *display,
VirtViewerDisplayChannel *channel,
VirtViewer *viewer)
{
int fd = -1;
g_return_if_fail(viewer != NULL);
g_return_if_fail(viewer->display != NULL);
if (viewer->transport && g_strcasecmp(viewer->transport, "ssh") == 0 &&
!viewer->direct) {
if ((fd = virt_viewer_open_tunnel_ssh(viewer->host, viewer->port, viewer->user,
viewer->ghost, viewer->gport, NULL)) < 0)
viewer->ghost, viewer->gport, NULL)) < 0)
virt_viewer_simple_message_dialog(viewer->window, _("Connect to ssh failed."));
} else
} else {
virt_viewer_simple_message_dialog(viewer->window, _("Can't connect to channel, SSH only supported."));
}
if (fd >= 0)
virt_viewer_display_channel_open_fd(VIRT_VIEWER_DISPLAY(viewer->display), channel, fd);
virt_viewer_display_channel_open_fd(display, channel, fd);
}
#else
void
virt_viewer_channel_open_fd(VirtViewer *viewer G_GNUC_UNUSED,
VirtViewerDisplayChannel *channel G_GNUC_UNUSED)
static void
virt_viewer_channel_open(VirtViewerDisplay *display,
VirtViewerDisplayChannel *channel,
VirtViewer *viewer)
{
virt_viewer_simple_message_dialog(viewer->window, _("Connect to channel unsupported."));
}
@ -1059,9 +1229,10 @@ virt_viewer_clipboard_copy(GtkClipboard *clipboard G_GNUC_UNUSED,
gtk_selection_data_set_text(data, viewer->clipboard, -1);
}
void
virt_viewer_server_cut_text(VirtViewer *viewer,
const gchar *text)
static void
virt_viewer_server_cut_text(VirtViewerDisplay *display G_GNUC_UNUSED,
const gchar *text,
VirtViewer *viewer)
{
GtkClipboard *cb;
gsize a, b;
@ -1090,6 +1261,14 @@ virt_viewer_server_cut_text(VirtViewer *viewer,
}
}
static void virt_viewer_bell(VirtViewerDisplay *display G_GNUC_UNUSED,
VirtViewer *viewer)
{
gdk_window_beep(gtk_widget_get_window(GTK_WIDGET(viewer->window)));
}
static gboolean
virt_viewer_retryauth(gpointer opaque)
{
@ -1138,31 +1317,72 @@ virt_viewer_deactivate(VirtViewer *viewer)
}
}
void
virt_viewer_connected(VirtViewer *viewer)
static void
virt_viewer_connected(VirtViewerDisplay *display G_GNUC_UNUSED,
VirtViewer *viewer)
{
viewer->connected = TRUE;
virt_viewer_set_status(viewer, "Connected to graphic server");
}
void
virt_viewer_initialized(VirtViewer *viewer)
static void
virt_viewer_initialized(VirtViewerDisplay *display G_GNUC_UNUSED,
VirtViewer *viewer)
{
virt_viewer_show_display(viewer);
virt_viewer_set_title(viewer, FALSE);
}
void
virt_viewer_disconnected(VirtViewer *viewer)
static void
virt_viewer_disconnected(VirtViewerDisplay *display G_GNUC_UNUSED,
VirtViewer *viewer)
{
if (!viewer->connected) {
virt_viewer_simple_message_dialog(viewer->window, _("Unable to connect to the graphic server %s"),
viewer->pretty_address);
virt_viewer_simple_message_dialog(viewer->window,
_("Unable to connect to the graphic server %s"),
viewer->pretty_address);
}
virt_viewer_deactivate(viewer);
}
static void virt_viewer_auth_refused(VirtViewerDisplay *display G_GNUC_UNUSED,
const char *msg,
VirtViewer *viewer)
{
GtkWidget *dialog;
int ret;
dialog = gtk_message_dialog_new(GTK_WINDOW(viewer->window),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_YES_NO,
_("Unable to authenticate with remote desktop server at %s: %s\n"
"Retry connection again?"),
viewer->pretty_address, msg);
ret = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
if (ret == GTK_RESPONSE_YES)
viewer->authretry = TRUE;
else
viewer->authretry = FALSE;
}
static void virt_viewer_auth_failed(VirtViewerDisplay *display G_GNUC_UNUSED,
const char *msg,
VirtViewer *viewer)
{
virt_viewer_simple_message_dialog(viewer->window,
_("Unable to authenticate with remote desktop server at %s"),
viewer->pretty_address, msg);
}
static int
virt_viewer_domain_event(virConnectPtr conn G_GNUC_UNUSED,
virDomainPtr dom,

4
src/virt-viewer.h
View File

@ -25,6 +25,10 @@
#include "virt-viewer-util.h"
typedef struct _VirtViewerDisplay VirtViewerDisplay;
typedef struct _VirtViewerDisplayClass VirtViewerDisplayClass;
typedef struct _VirtViewer VirtViewer;
extern int virt_viewer_start(const char *uri,
const char *name,
gint zoom,