GNOME.org
 

[PATCH 23/25] Rename enums from GVNC_ to VNC_CONNECTION_

Rename the symbols for the VncConnectionEncoding, VncConnectionAuth
and VncConnectionAuthVencrypt enums to use a prefix of
VNC_CONNECTION_ instead of GVNC_
---
 src/vncconnection.c |  104 +++++++++++++++++++++++++-------------------------
 src/vncconnection.h |   88 +++++++++++++++++++++---------------------
 src/vncdisplay.c    |   40 ++++++++++----------
 3 files changed, 116 insertions(+), 116 deletions(-)

diff --git a/src/vncconnection.c b/src/vncconnection.c
index aeeaf1f..299164a 100644
--- a/src/vncconnection.c
+++ b/src/vncconnection.c
@@ -1287,7 +1287,7 @@ gboolean vnc_connection_set_encodings(VncConnection *conn, int n_encoding, gint3
 		    (priv->fmt.red_max > 255 ||
 		     priv->fmt.blue_max > 255 ||
 		     priv->fmt.green_max > 255) &&
-		    encoding[i] == GVNC_ENCODING_ZRLE) {
+		    encoding[i] == VNC_CONNECTION_ENCODING_ZRLE) {
 			GVNC_DEBUG("Dropping ZRLE encoding for broken pixel format");
 			skip_zrle++;
 		}
@@ -1297,7 +1297,7 @@ gboolean vnc_connection_set_encodings(VncConnection *conn, int n_encoding, gint3
 	vnc_connection_write(conn, pad, 1);
 	vnc_connection_write_u16(conn, n_encoding - skip_zrle);
 	for (i = 0; i < n_encoding; i++) {
-		if (skip_zrle && encoding[i] == GVNC_ENCODING_ZRLE)
+		if (skip_zrle && encoding[i] == VNC_CONNECTION_ENCODING_ZRLE)
 			continue;
 		vnc_connection_write_s32(conn, encoding[i]);
 	}
@@ -2462,48 +2462,48 @@ static void vnc_connection_framebuffer_update(VncConnection *conn, gint32 etype,
 		   etype, width, height, x, y);
 
 	switch (etype) {
-	case GVNC_ENCODING_RAW:
+	case VNC_CONNECTION_ENCODING_RAW:
 		vnc_connection_raw_update(conn, x, y, width, height);
 		vnc_connection_update(conn, x, y, width, height);
 		break;
-	case GVNC_ENCODING_COPY_RECT:
+	case VNC_CONNECTION_ENCODING_COPY_RECT:
 		vnc_connection_copyrect_update(conn, x, y, width, height);
 		vnc_connection_update(conn, x, y, width, height);
 		break;
-	case GVNC_ENCODING_RRE:
+	case VNC_CONNECTION_ENCODING_RRE:
 		vnc_connection_rre_update(conn, x, y, width, height);
 		vnc_connection_update(conn, x, y, width, height);
 		break;
-	case GVNC_ENCODING_HEXTILE:
+	case VNC_CONNECTION_ENCODING_HEXTILE:
 		vnc_connection_hextile_update(conn, x, y, width, height);
 		vnc_connection_update(conn, x, y, width, height);
 		break;
-	case GVNC_ENCODING_ZRLE:
+	case VNC_CONNECTION_ENCODING_ZRLE:
 		vnc_connection_zrle_update(conn, x, y, width, height);
 		vnc_connection_update(conn, x, y, width, height);
 		break;
-	case GVNC_ENCODING_TIGHT:
+	case VNC_CONNECTION_ENCODING_TIGHT:
 		vnc_connection_tight_update(conn, x, y, width, height);
 		vnc_connection_update(conn, x, y, width, height);
 		break;
-	case GVNC_ENCODING_DESKTOP_RESIZE:
+	case VNC_CONNECTION_ENCODING_DESKTOP_RESIZE:
 		vnc_connection_framebuffer_update_request (conn, 0, 0, 0, width, height);
 		vnc_connection_resize(conn, width, height);
 		break;
-	case GVNC_ENCODING_POINTER_CHANGE:
+	case VNC_CONNECTION_ENCODING_POINTER_CHANGE:
 		vnc_connection_pointer_type_change(conn, x);
 		break;
-        case GVNC_ENCODING_WMVi:
+        case VNC_CONNECTION_ENCODING_WMVi:
                 vnc_connection_read_pixel_format(conn, &priv->fmt);
                 vnc_connection_pixel_format(conn);
                 break;
-	case GVNC_ENCODING_RICH_CURSOR:
+	case VNC_CONNECTION_ENCODING_RICH_CURSOR:
 		vnc_connection_rich_cursor(conn, x, y, width, height);
 		break;
-	case GVNC_ENCODING_XCURSOR:
+	case VNC_CONNECTION_ENCODING_XCURSOR:
 		vnc_connection_xcursor(conn, x, y, width, height);
 		break;
-	case GVNC_ENCODING_EXT_KEY_EVENT:
+	case VNC_CONNECTION_ENCODING_EXT_KEY_EVENT:
 		vnc_connection_ext_key_event(conn);
 		break;
 	default:
@@ -3429,7 +3429,7 @@ static gboolean vnc_connection_has_auth_subtype(gpointer data)
 
 	if (priv->has_error)
 		return TRUE;
-	if (priv->auth_subtype == GVNC_AUTH_INVALID)
+	if (priv->auth_subtype == VNC_CONNECTION_AUTH_INVALID)
 		return FALSE;
 	return TRUE;
 }
@@ -3452,7 +3452,7 @@ static void vnc_connection_choose_auth(VncConnection *conn,
 		if (signum == VNC_AUTH_CHOOSE_TYPE) {
 			g_value_init(&authType, VNC_TYPE_CONNECTION_AUTH);
 		} else {
-			if (priv->auth_type == GVNC_AUTH_VENCRYPT)
+			if (priv->auth_type == VNC_CONNECTION_AUTH_VENCRYPT)
 				g_value_init(&authType, VNC_TYPE_CONNECTION_AUTH_VENCRYPT);
 			else
 				g_value_init(&authType, VNC_TYPE_CONNECTION_AUTH);
@@ -3519,14 +3519,14 @@ static gboolean vnc_connection_perform_auth_tls(VncConnection *conn)
 	vnc_connection_flush(conn);
 
 	switch (priv->auth_subtype) {
-	case GVNC_AUTH_NONE:
+	case VNC_CONNECTION_AUTH_NONE:
 		if (priv->minor == 8)
 			return vnc_connection_check_auth_result(conn);
 		return TRUE;
-	case GVNC_AUTH_VNC:
+	case VNC_CONNECTION_AUTH_VNC:
 		return vnc_connection_perform_auth_vnc(conn);
 #if HAVE_SASL
-	case GVNC_AUTH_SASL:
+	case VNC_CONNECTION_AUTH_SASL:
 		return vnc_connection_perform_auth_sasl(conn);
 #endif
 	default:
@@ -3592,7 +3592,7 @@ static gboolean vnc_connection_perform_auth_vencrypt(VncConnection *conn)
 		return FALSE;
 
 #if !DEBUG
-	if (priv->auth_subtype == GVNC_AUTH_VENCRYPT_PLAIN) {
+	if (priv->auth_subtype == VNC_CONNECTION_AUTH_VENCRYPT_PLAIN) {
 		GVNC_DEBUG("Cowardly refusing to transmit plain text password");
 		return FALSE;
 	}
@@ -3607,10 +3607,10 @@ static gboolean vnc_connection_perform_auth_vencrypt(VncConnection *conn)
 	}
 
 	switch (priv->auth_subtype) {
-	case GVNC_AUTH_VENCRYPT_TLSNONE:
-	case GVNC_AUTH_VENCRYPT_TLSPLAIN:
-	case GVNC_AUTH_VENCRYPT_TLSVNC:
-	case GVNC_AUTH_VENCRYPT_TLSSASL:
+	case VNC_CONNECTION_AUTH_VENCRYPT_TLSNONE:
+	case VNC_CONNECTION_AUTH_VENCRYPT_TLSPLAIN:
+	case VNC_CONNECTION_AUTH_VENCRYPT_TLSVNC:
+	case VNC_CONNECTION_AUTH_VENCRYPT_TLSSASL:
 		anonTLS = 1;
 		break;
 	default:
@@ -3625,21 +3625,21 @@ static gboolean vnc_connection_perform_auth_vencrypt(VncConnection *conn)
 
 	switch (priv->auth_subtype) {
 		/* Plain certificate based auth */
-	case GVNC_AUTH_VENCRYPT_TLSNONE:
-	case GVNC_AUTH_VENCRYPT_X509NONE:
+	case VNC_CONNECTION_AUTH_VENCRYPT_TLSNONE:
+	case VNC_CONNECTION_AUTH_VENCRYPT_X509NONE:
 		GVNC_DEBUG("Completing auth");
 		return vnc_connection_check_auth_result(conn);
 
 		/* Regular VNC layered over TLS */
-	case GVNC_AUTH_VENCRYPT_TLSVNC:
-	case GVNC_AUTH_VENCRYPT_X509VNC:
+	case VNC_CONNECTION_AUTH_VENCRYPT_TLSVNC:
+	case VNC_CONNECTION_AUTH_VENCRYPT_X509VNC:
 		GVNC_DEBUG("Handing off to VNC auth");
 		return vnc_connection_perform_auth_vnc(conn);
 
 #if HAVE_SASL
 		/* SASL layered over TLS */
-	case GVNC_AUTH_VENCRYPT_TLSSASL:
-	case GVNC_AUTH_VENCRYPT_X509SASL:
+	case VNC_CONNECTION_AUTH_VENCRYPT_TLSSASL:
+	case VNC_CONNECTION_AUTH_VENCRYPT_X509SASL:
 		GVNC_DEBUG("Handing off to SASL auth");
 		return vnc_connection_perform_auth_sasl(conn);
 #endif
@@ -3657,7 +3657,7 @@ static gboolean vnc_connection_has_auth_type(gpointer data)
 
 	if (priv->has_error)
 		return TRUE;
-	if (priv->auth_type == GVNC_AUTH_INVALID)
+	if (priv->auth_type == VNC_CONNECTION_AUTH_INVALID)
 		return FALSE;
 	return TRUE;
 }
@@ -3712,27 +3712,27 @@ static gboolean vnc_connection_perform_auth(VncConnection *conn)
 	}
 
 	switch (priv->auth_type) {
-	case GVNC_AUTH_NONE:
+	case VNC_CONNECTION_AUTH_NONE:
 		if (priv->minor == 8)
 			return vnc_connection_check_auth_result(conn);
 		return TRUE;
-	case GVNC_AUTH_VNC:
+	case VNC_CONNECTION_AUTH_VNC:
 		return vnc_connection_perform_auth_vnc(conn);
 
-	case GVNC_AUTH_TLS:
+	case VNC_CONNECTION_AUTH_TLS:
 		if (priv->minor < 7)
 			return FALSE;
 		return vnc_connection_perform_auth_tls(conn);
 
-	case GVNC_AUTH_VENCRYPT:
+	case VNC_CONNECTION_AUTH_VENCRYPT:
 		return vnc_connection_perform_auth_vencrypt(conn);
 
 #if HAVE_SASL
-	case GVNC_AUTH_SASL:
+	case VNC_CONNECTION_AUTH_SASL:
  		return vnc_connection_perform_auth_sasl(conn);
 #endif
 
-	case GVNC_AUTH_MSLOGON:
+	case VNC_CONNECTION_AUTH_MSLOGON:
 		return vnc_connection_perform_auth_mslogon(conn);
 
 	default:
@@ -3936,8 +3936,8 @@ void vnc_connection_init(VncConnection *fb)
 	memset(priv, 0, sizeof(*priv));
 
 	priv->fd = -1;
-	priv->auth_type = GVNC_AUTH_INVALID;
-	priv->auth_subtype = GVNC_AUTH_INVALID;
+	priv->auth_type = VNC_CONNECTION_AUTH_INVALID;
+	priv->auth_subtype = VNC_CONNECTION_AUTH_INVALID;
 }
 
 
@@ -4016,8 +4016,8 @@ void vnc_connection_close(VncConnection *conn)
 	for (i = 0; i < 5; i++)
 		inflateEnd(&priv->streams[i]);
 
-	priv->auth_type = GVNC_AUTH_INVALID;
-	priv->auth_subtype = GVNC_AUTH_INVALID;
+	priv->auth_type = VNC_CONNECTION_AUTH_INVALID;
+	priv->auth_subtype = VNC_CONNECTION_AUTH_INVALID;
 
 	priv->has_error = 0;
 }
@@ -4293,16 +4293,16 @@ gboolean vnc_connection_set_auth_type(VncConnection *conn, unsigned int type)
 	VncConnectionPrivate *priv = conn->priv;
 
         GVNC_DEBUG("Thinking about auth type %u", type);
-        if (priv->auth_type != GVNC_AUTH_INVALID) {
+        if (priv->auth_type != VNC_CONNECTION_AUTH_INVALID) {
                 priv->has_error = TRUE;
                 return !vnc_connection_has_error(conn);
         }
-        if (type != GVNC_AUTH_NONE &&
-            type != GVNC_AUTH_VNC &&
-            type != GVNC_AUTH_MSLOGON &&
-            type != GVNC_AUTH_TLS &&
-            type != GVNC_AUTH_VENCRYPT &&
-            type != GVNC_AUTH_SASL) {
+        if (type != VNC_CONNECTION_AUTH_NONE &&
+            type != VNC_CONNECTION_AUTH_VNC &&
+            type != VNC_CONNECTION_AUTH_MSLOGON &&
+            type != VNC_CONNECTION_AUTH_TLS &&
+            type != VNC_CONNECTION_AUTH_VENCRYPT &&
+            type != VNC_CONNECTION_AUTH_SASL) {
 		struct signal_data sigdata;
 		GVNC_DEBUG("Unsupported auth type %u", type);
 		sigdata.params.authUnsupported = type;
@@ -4312,7 +4312,7 @@ gboolean vnc_connection_set_auth_type(VncConnection *conn, unsigned int type)
         }
         GVNC_DEBUG("Decided on auth type %u", type);
         priv->auth_type = type;
-        priv->auth_subtype = GVNC_AUTH_INVALID;
+        priv->auth_subtype = VNC_CONNECTION_AUTH_INVALID;
 
 	return !vnc_connection_has_error(conn);
 }
@@ -4322,12 +4322,12 @@ gboolean vnc_connection_set_auth_subtype(VncConnection *conn, unsigned int type)
 	VncConnectionPrivate *priv = conn->priv;
 
         GVNC_DEBUG("Requested auth subtype %d", type);
-        if (priv->auth_type != GVNC_AUTH_VENCRYPT &&
-	    priv->auth_type != GVNC_AUTH_TLS) {
+        if (priv->auth_type != VNC_CONNECTION_AUTH_VENCRYPT &&
+	    priv->auth_type != VNC_CONNECTION_AUTH_TLS) {
                 priv->has_error = TRUE;
 		return !vnc_connection_has_error(conn);
         }
-        if (priv->auth_subtype != GVNC_AUTH_INVALID) {
+        if (priv->auth_subtype != VNC_CONNECTION_AUTH_INVALID) {
                 priv->has_error = TRUE;
 		return !vnc_connection_has_error(conn);
         }
diff --git a/src/vncconnection.h b/src/vncconnection.h
index 6c9cd11..949dfaa 100644
--- a/src/vncconnection.h
+++ b/src/vncconnection.h
@@ -73,62 +73,62 @@ struct vnc_connection_ops
 
 
 typedef enum {
-	GVNC_ENCODING_RAW = 0,
-	GVNC_ENCODING_COPY_RECT = 1,
-	GVNC_ENCODING_RRE = 2,
-	GVNC_ENCODING_CORRE = 4,
-	GVNC_ENCODING_HEXTILE = 5,
-	GVNC_ENCODING_TIGHT = 7,
-	GVNC_ENCODING_ZRLE = 16,
+	VNC_CONNECTION_ENCODING_RAW = 0,
+	VNC_CONNECTION_ENCODING_COPY_RECT = 1,
+	VNC_CONNECTION_ENCODING_RRE = 2,
+	VNC_CONNECTION_ENCODING_CORRE = 4,
+	VNC_CONNECTION_ENCODING_HEXTILE = 5,
+	VNC_CONNECTION_ENCODING_TIGHT = 7,
+	VNC_CONNECTION_ENCODING_ZRLE = 16,
 
 	/* Tight JPEG quality levels */
-	GVNC_ENCODING_TIGHT_JPEG0 = -32,
-	GVNC_ENCODING_TIGHT_JPEG1 = -31,
-	GVNC_ENCODING_TIGHT_JPEG2 = -30,
-	GVNC_ENCODING_TIGHT_JPEG3 = -29,
-	GVNC_ENCODING_TIGHT_JPEG4 = -28,
-	GVNC_ENCODING_TIGHT_JPEG5 = -27,
-	GVNC_ENCODING_TIGHT_JPEG6 = -26,
-	GVNC_ENCODING_TIGHT_JPEG7 = -25,
-	GVNC_ENCODING_TIGHT_JPEG8 = -24,
-	GVNC_ENCODING_TIGHT_JPEG9 = -23,
+	VNC_CONNECTION_ENCODING_TIGHT_JPEG0 = -32,
+	VNC_CONNECTION_ENCODING_TIGHT_JPEG1 = -31,
+	VNC_CONNECTION_ENCODING_TIGHT_JPEG2 = -30,
+	VNC_CONNECTION_ENCODING_TIGHT_JPEG3 = -29,
+	VNC_CONNECTION_ENCODING_TIGHT_JPEG4 = -28,
+	VNC_CONNECTION_ENCODING_TIGHT_JPEG5 = -27,
+	VNC_CONNECTION_ENCODING_TIGHT_JPEG6 = -26,
+	VNC_CONNECTION_ENCODING_TIGHT_JPEG7 = -25,
+	VNC_CONNECTION_ENCODING_TIGHT_JPEG8 = -24,
+	VNC_CONNECTION_ENCODING_TIGHT_JPEG9 = -23,
 
 	/* Pseudo encodings */
-	GVNC_ENCODING_DESKTOP_RESIZE = -223,
-        GVNC_ENCODING_WMVi = 0x574D5669,
+	VNC_CONNECTION_ENCODING_DESKTOP_RESIZE = -223,
+        VNC_CONNECTION_ENCODING_WMVi = 0x574D5669,
 
-	GVNC_ENCODING_CURSOR_POS = -232,
-	GVNC_ENCODING_RICH_CURSOR = -239,
-	GVNC_ENCODING_XCURSOR = -240,
+	VNC_CONNECTION_ENCODING_CURSOR_POS = -232,
+	VNC_CONNECTION_ENCODING_RICH_CURSOR = -239,
+	VNC_CONNECTION_ENCODING_XCURSOR = -240,
 
-	GVNC_ENCODING_POINTER_CHANGE = -257,
-	GVNC_ENCODING_EXT_KEY_EVENT = -258,
+	VNC_CONNECTION_ENCODING_POINTER_CHANGE = -257,
+	VNC_CONNECTION_ENCODING_EXT_KEY_EVENT = -258,
 } VncConnectionEncoding;
 
 typedef enum {
-	GVNC_AUTH_INVALID = 0,
-	GVNC_AUTH_NONE = 1,
-	GVNC_AUTH_VNC = 2,
-	GVNC_AUTH_RA2 = 5,
-	GVNC_AUTH_RA2NE = 6,
-	GVNC_AUTH_TIGHT = 16,
-	GVNC_AUTH_ULTRA = 17,
-	GVNC_AUTH_TLS = 18,  /* Used by VINO */
-	GVNC_AUTH_VENCRYPT = 19, /* Used by VeNCrypt and QEMU */
- 	GVNC_AUTH_SASL = 20, /* SASL type used by VINO and QEMU */
-	GVNC_AUTH_MSLOGON = 0xfffffffa, /* Used by UltraVNC */
+	VNC_CONNECTION_AUTH_INVALID = 0,
+	VNC_CONNECTION_AUTH_NONE = 1,
+	VNC_CONNECTION_AUTH_VNC = 2,
+	VNC_CONNECTION_AUTH_RA2 = 5,
+	VNC_CONNECTION_AUTH_RA2NE = 6,
+	VNC_CONNECTION_AUTH_TIGHT = 16,
+	VNC_CONNECTION_AUTH_ULTRA = 17,
+	VNC_CONNECTION_AUTH_TLS = 18,  /* Used by VINO */
+	VNC_CONNECTION_AUTH_VENCRYPT = 19, /* Used by VeNCrypt and QEMU */
+ 	VNC_CONNECTION_AUTH_SASL = 20, /* SASL type used by VINO and QEMU */
+	VNC_CONNECTION_AUTH_MSLOGON = 0xfffffffa, /* Used by UltraVNC */
 } VncConnectionAuth;
 
 typedef enum {
-	GVNC_AUTH_VENCRYPT_PLAIN = 256,
-	GVNC_AUTH_VENCRYPT_TLSNONE = 257,
-	GVNC_AUTH_VENCRYPT_TLSVNC = 258,
-	GVNC_AUTH_VENCRYPT_TLSPLAIN = 259,
-	GVNC_AUTH_VENCRYPT_X509NONE = 260,
-	GVNC_AUTH_VENCRYPT_X509VNC = 261,
-	GVNC_AUTH_VENCRYPT_X509PLAIN = 262,
-	GVNC_AUTH_VENCRYPT_X509SASL = 263,
-	GVNC_AUTH_VENCRYPT_TLSSASL = 264,
+	VNC_CONNECTION_AUTH_VENCRYPT_PLAIN = 256,
+	VNC_CONNECTION_AUTH_VENCRYPT_TLSNONE = 257,
+	VNC_CONNECTION_AUTH_VENCRYPT_TLSVNC = 258,
+	VNC_CONNECTION_AUTH_VENCRYPT_TLSPLAIN = 259,
+	VNC_CONNECTION_AUTH_VENCRYPT_X509NONE = 260,
+	VNC_CONNECTION_AUTH_VENCRYPT_X509VNC = 261,
+	VNC_CONNECTION_AUTH_VENCRYPT_X509PLAIN = 262,
+	VNC_CONNECTION_AUTH_VENCRYPT_X509SASL = 263,
+	VNC_CONNECTION_AUTH_VENCRYPT_TLSSASL = 264,
 } VncConnectionAuthVencrypt;
 
 typedef enum
diff --git a/src/vncdisplay.c b/src/vncdisplay.c
index 197abf5..09a84a8 100644
--- a/src/vncdisplay.c
+++ b/src/vncdisplay.c
@@ -1133,7 +1133,7 @@ static void on_auth_choose_subtype(VncConnection *conn G_GNUC_UNUSED,
 	if (!subtypes->n_values)
 		return;
 
-	if (type == GVNC_AUTH_TLS) {
+	if (type == VNC_CONNECTION_AUTH_TLS) {
 		for (l = priv->preferable_auths; l; l=l->next) {
 			int pref = GPOINTER_TO_UINT (l->data);
 
@@ -1283,19 +1283,19 @@ static void *vnc_coroutine(void *opaque)
 	VncDisplayPrivate *priv = obj->priv;
 
 	/* this order is extremely important! */
-	gint32 encodings[] = {	GVNC_ENCODING_TIGHT_JPEG5,
-				GVNC_ENCODING_TIGHT,
-				GVNC_ENCODING_EXT_KEY_EVENT,
-				GVNC_ENCODING_DESKTOP_RESIZE,
-                                GVNC_ENCODING_WMVi,
-				GVNC_ENCODING_RICH_CURSOR,
-				GVNC_ENCODING_XCURSOR,
-				GVNC_ENCODING_POINTER_CHANGE,
-				GVNC_ENCODING_ZRLE,
-				GVNC_ENCODING_HEXTILE,
-				GVNC_ENCODING_RRE,
-				GVNC_ENCODING_COPY_RECT,
-				GVNC_ENCODING_RAW };
+	gint32 encodings[] = {	VNC_CONNECTION_ENCODING_TIGHT_JPEG5,
+				VNC_CONNECTION_ENCODING_TIGHT,
+				VNC_CONNECTION_ENCODING_EXT_KEY_EVENT,
+				VNC_CONNECTION_ENCODING_DESKTOP_RESIZE,
+                                VNC_CONNECTION_ENCODING_WMVi,
+				VNC_CONNECTION_ENCODING_RICH_CURSOR,
+				VNC_CONNECTION_ENCODING_XCURSOR,
+				VNC_CONNECTION_ENCODING_POINTER_CHANGE,
+				VNC_CONNECTION_ENCODING_ZRLE,
+				VNC_CONNECTION_ENCODING_HEXTILE,
+				VNC_CONNECTION_ENCODING_RRE,
+				VNC_CONNECTION_ENCODING_COPY_RECT,
+				VNC_CONNECTION_ENCODING_RAW };
 	gint32 *encodingsp;
 	int n_encodings;
 	int ret;
@@ -1922,20 +1922,20 @@ static void vnc_display_init(VncDisplay *display)
 	 * all the other auth types on top. So these two must
 	 * be the first listed
 	 */
-	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (GVNC_AUTH_VENCRYPT));
-	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (GVNC_AUTH_TLS));
+	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (VNC_CONNECTION_AUTH_VENCRYPT));
+	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (VNC_CONNECTION_AUTH_TLS));
 
 	/*
 	 * Then stackable auth types in order of preference
 	 */
-	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (GVNC_AUTH_SASL));
-	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (GVNC_AUTH_MSLOGON));
-	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (GVNC_AUTH_VNC));
+	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (VNC_CONNECTION_AUTH_SASL));
+	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (VNC_CONNECTION_AUTH_MSLOGON));
+	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (VNC_CONNECTION_AUTH_VNC));
 
 	/*
 	 * Or nothing at all
 	 */
-	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (GVNC_AUTH_NONE));
+	priv->preferable_auths = g_slist_append (priv->preferable_auths, GUINT_TO_POINTER (VNC_CONNECTION_AUTH_NONE));
 
 	priv->conn = vnc_connection_new();
 
-- 
1.6.5.2
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]