Commits

Joe Nassimian committed 48251ab

partially ported from deprecated symbols to new ones

  • Participants
  • Parent commits 4e9a7e7

Comments (0)

Files changed (56)

libpurple/media/backend-fs2.c

 			(GSourceFunc)src_pad_added_cb_cb, stream);
 }
 
-static GValueArray *
-append_relay_info(GValueArray *relay_info, const gchar *ip, gint port,
-	const gchar *username, const gchar *password, const gchar *type)
-{
-	GValue value;
-	GstStructure *turn_setup = gst_structure_new("relay-info",
-				"ip", G_TYPE_STRING, ip,
-				"port", G_TYPE_UINT, port,
-				"username", G_TYPE_STRING, username,
-				"password", G_TYPE_STRING, password,
-				"relay-type", G_TYPE_STRING, type,
-				NULL);
-
-	if (turn_setup) {
-		memset(&value, 0, sizeof(GValue));
-		g_value_init(&value, GST_TYPE_STRUCTURE);
-		gst_value_set_structure(&value, turn_setup);
-		relay_info = g_value_array_append(relay_info, &value);
-		gst_structure_free(turn_setup);
-	}
-
-	return relay_info;
-}
-
-static gboolean
-create_stream(PurpleMediaBackendFs2 *self,
-		const gchar *sess_id, const gchar *who,
-		PurpleMediaSessionType type, gboolean initiator,
-		const gchar *transmitter,
-		guint num_params, GParameter *params)
+static gboolean create_stream(
+	PurpleMediaBackendFs2 *self,
+	const gchar *sess_id, const gchar *who,
+	PurpleMediaSessionType type, gboolean initiator,
+	const gchar *transmitter,
+	guint num_params, GParameter *params
+)
 {
 	PurpleMediaBackendFs2Private *priv =
-			PURPLE_MEDIA_BACKEND_FS2_GET_PRIVATE(self);
+		PURPLE_MEDIA_BACKEND_FS2_GET_PRIVATE(self);
 	GError *err = NULL;
 	FsStream *fsstream = NULL;
 	const gchar *stun_ip = purple_network_get_stun_ip();
 	guint _num_params = num_params;
 	GParameter *_params;
 	FsStreamDirection type_direction =
-			session_type_to_fs_stream_direction(type);
+		session_type_to_fs_stream_direction(type);
 	PurpleMediaBackendFs2Session *session;
 	PurpleMediaBackendFs2Stream *stream;
 	FsParticipant *participant;
 			(type_direction & FS_DIRECTION_RECV), &err);
 
 	if (fsstream == NULL) {
-		if (err) {
+		if (err)
+		{
 			purple_debug_error("backend-fs2",
-					"Error creating stream: %s\n",
-					err && err->message ?
-					err->message : "NULL");
+				"Error creating stream: %s\n",
+				err && err->message ?
+				err->message : "NULL"
+			);
 			g_error_free(err);
-		} else
-			purple_debug_error("backend-fs2",
-					"Error creating stream\n");
+		}
+		else
+		{
+			purple_debug_error("backend-fs2", "Error creating stream\n");
+		}
 		return FALSE;
 	}
 #endif
 
-	for (i = 0 ; i < num_params ; i++) {
+	for (i = 0; i < num_params; ++i) {
 		if (purple_strequal(params[i].name, "relay-info")) {
 			got_turn_from_prpl = TRUE;
 			break;
 	}
 
 	if (turn_ip && !strcmp("nice", transmitter) && !got_turn_from_prpl) {
-		GValueArray *relay_info = g_value_array_new(0);
+		GArray *relay_info = g_array_new(FALSE, FALSE, sizeof(GstStructure));
 		gint port;
+
 		const gchar *username =	purple_prefs_get_string(
-				"/purple/network/turn_username");
+			"/purple/network/turn_username"
+		);
 		const gchar *password = purple_prefs_get_string(
-				"/purple/network/turn_password");
+			"/purple/network/turn_password"
+		);
+
+
 
 		/* UDP */
 		port = purple_prefs_get_int("/purple/network/turn_port");
-		if (port > 0) {
-			relay_info = append_relay_info(relay_info, turn_ip, port, username,
-				password, "udp");
+		if (port > 0)
+		{
+			GstStructure *turn_setup = gst_structure_new(
+				"relay-info",
+				"ip", G_TYPE_STRING, turn_ip,
+				"port", G_TYPE_UINT, port,
+				"username", G_TYPE_STRING, username,
+				"password", G_TYPE_STRING, password,
+				"relay-type", G_TYPE_STRING, "udp",
+				NULL
+			);
+			if (turn_setup)
+			{
+				relay_info = g_array_append_vals(relay_info, turn_setup, 1);
+				gst_structure_free(turn_setup);
+			}
 		}
-		
+
 		/* TCP */
 		port = purple_prefs_get_int("/purple/network/turn_port_tcp");
-		if (port > 0) {
-			relay_info = append_relay_info(relay_info, turn_ip, port, username,
-				password, "tcp");
+		if (port > 0)
+		{
+			GstStructure *turn_setup = gst_structure_new(
+				"relay-info",
+				"ip", G_TYPE_STRING, turn_ip,
+				"port", G_TYPE_UINT, port,
+				"username", G_TYPE_STRING, username,
+				"password", G_TYPE_STRING, password,
+				"relay-type", G_TYPE_STRING, "tcp",
+				NULL
+			);
+			if (turn_setup)
+			{
+				relay_info = g_array_append_vals(relay_info, turn_setup, 1);
+				gst_structure_free(turn_setup);
+			}
 		}
 
-		/* TURN over SSL is only supported by libnice for Google's "psuedo" SSL mode
-			at this time */
-
-		purple_debug_info("backend-fs2",
-			"Setting relay-info on new stream\n");
+
+
+		/* TURN over SSL is only supported by libnice for Google's "pseudo" SSL
+		 * mode at this time.
+		 */
+
+		purple_debug_info(
+			"backend-fs2",
+			"Setting relay-info on new stream\n"
+		);
+
 		_params[_num_params].name = "relay-info";
-		g_value_init(&_params[_num_params].value,
-			G_TYPE_VALUE_ARRAY);
-		g_value_set_boxed(&_params[_num_params].value,
-			relay_info);
-		g_value_array_free(relay_info);
-		_num_params++;
+		g_value_init(&_params[_num_params].value, G_TYPE_ARRAY);
+		g_value_set_boxed(&_params[_num_params].value, relay_info);
+
+		g_array_unref(relay_info);
+		++_num_params;
 	}
 
 #ifdef HAVE_FARSIGHT

libpurple/plugins/ssl/ssl-gnutls.c

 
 typedef struct
 {
-	gnutls_session session;
+	gnutls_session_t session;
 	guint handshake_handler;
 	guint handshake_timer;
 } PurpleSslGnutlsData;
 		g_list_free(peers);
 
 		{
-			const gnutls_datum *cert_list;
+			const gnutls_datum_t *cert_list;
 			unsigned int cert_list_size = 0;
-			gnutls_session session=gnutls_data->session;
+			gnutls_session_t session = gnutls_data->session;
 			int i;
 
 			cert_list =
 				gchar tbuf[256];
 				gsize tsz=sizeof(tbuf);
 				gchar * tasc = NULL;
-				gnutls_x509_crt cert;
+				gnutls_x509_crt_t cert;
 
 				gnutls_x509_crt_init(&cert);
 				gnutls_x509_crt_import (cert, &cert_list[i],
 
 /* Forward declarations are fun! */
 static PurpleCertificate *
-x509_import_from_datum(const gnutls_datum dt, gnutls_x509_crt_fmt mode);
+x509_import_from_datum(const gnutls_datum_t dt, gnutls_x509_crt_fmt_t mode);
 /* indeed! */
 static gboolean
 x509_certificate_signed_by(PurpleCertificate * crt,
 	GList * peer_certs = NULL;
 
 	/* List of raw certificates as given by GnuTLS */
-	const gnutls_datum *cert_list;
+	const gnutls_datum_t *cert_list;
 	unsigned int cert_list_size = 0;
 
 	unsigned int i;
 /** Refcounted GnuTLS certificate data instance */
 typedef struct {
 	gint refcount;
-	gnutls_x509_crt crt;
+	gnutls_x509_crt_t crt;
 } x509_crtdata_t;
 
 /** Helper functions for reference counting */
  * @return A newly allocated Certificate structure of the x509_gnutls scheme
  */
 static PurpleCertificate *
-x509_import_from_datum(const gnutls_datum dt, gnutls_x509_crt_fmt mode)
+x509_import_from_datum(const gnutls_datum_t dt, gnutls_x509_crt_fmt_t mode)
 {
 	/* Internal certificate data structure */
 	x509_crtdata_t *certdat;
 	PurpleCertificate *crt;  /* Certificate being constructed */
 	gchar *buf;        /* Used to load the raw file data */
 	gsize buf_sz;      /* Size of the above */
-	gnutls_datum dt; /* Struct to pass down to GnuTLS */
+	gnutls_datum_t dt; /* Struct to pass down to GnuTLS */
 
 	purple_debug_info("gnutls",
 			  "Attempting to load X.509 certificate from %s\n",
 	gchar *begin, *end;
 	GSList *crts = NULL;
 	gsize buf_sz;      /* Size of the above */
-	gnutls_datum dt; /* Struct to pass down to GnuTLS */
+	gnutls_datum_t dt; /* Struct to pass down to GnuTLS */
 
 	purple_debug_info("gnutls",
 			  "Attempting to load X.509 certificates from %s\n",
 static gboolean
 x509_export_certificate(const gchar *filename, PurpleCertificate *crt)
 {
-	gnutls_x509_crt crt_dat; /* GnuTLS cert struct */
+	gnutls_x509_crt_t crt_dat; /* GnuTLS cert struct */
 	int ret;
 	gchar * out_buf; /* Data to output */
 	size_t out_size; /* Output size */
 x509_certificate_signed_by(PurpleCertificate * crt,
 			   PurpleCertificate * issuer)
 {
-	gnutls_x509_crt crt_dat;
-	gnutls_x509_crt issuer_dat;
+	gnutls_x509_crt_t crt_dat;
+	gnutls_x509_crt_t issuer_dat;
 	unsigned int verify; /* used to store result from GnuTLS verifier */
 	int ret;
 	gchar *crt_id = NULL;
 {
 	size_t hashlen = 20; /* SHA1 hashes are 20 bytes */
 	size_t tmpsz = hashlen; /* Throw-away variable for GnuTLS to stomp on*/
-	gnutls_x509_crt crt_dat;
+	gnutls_x509_crt_t crt_dat;
 	GByteArray *hash; /**< Final hash container */
 	guchar hashbuf[hashlen]; /**< Temporary buffer to contain hash */
 
 static gchar *
 x509_cert_dn (PurpleCertificate *crt)
 {
-	gnutls_x509_crt cert_dat;
+	gnutls_x509_crt_t cert_dat;
 	gchar *dn = NULL;
 	size_t dn_size;
 
 static gchar *
 x509_issuer_dn (PurpleCertificate *crt)
 {
-	gnutls_x509_crt cert_dat;
+	gnutls_x509_crt_t cert_dat;
 	gchar *dn = NULL;
 	size_t dn_size;
 
 static gchar *
 x509_common_name (PurpleCertificate *crt)
 {
-	gnutls_x509_crt cert_dat;
+	gnutls_x509_crt_t cert_dat;
 	gchar *cn = NULL;
 	size_t cn_size;
 	int ret;
 static gboolean
 x509_check_name (PurpleCertificate *crt, const gchar *name)
 {
-	gnutls_x509_crt crt_dat;
+	gnutls_x509_crt_t crt_dat;
 
 	g_return_val_if_fail(crt, FALSE);
 	g_return_val_if_fail(crt->scheme == &x509_gnutls, FALSE);
 static gboolean
 x509_times (PurpleCertificate *crt, time_t *activation, time_t *expiration)
 {
-	gnutls_x509_crt crt_dat;
+	gnutls_x509_crt_t crt_dat;
 	/* GnuTLS time functions return this on error */
 	const time_t errval = (time_t) (-1);
 	gboolean success = TRUE;
 static GByteArray *
 x509_get_der_data(PurpleCertificate *crt)
 {
-	gnutls_x509_crt crt_dat;
+	gnutls_x509_crt_t crt_dat;
 	GByteArray *data;
 	size_t len;
 	int ret;

libpurple/plugins/tcl/tcl_glib.c

 static gboolean tcl_timer_pending;
 static GHashTable *tcl_file_handlers;
 
-static void tcl_set_timer(Tcl_Time *timePtr);
-static int tcl_wait_for_event(Tcl_Time *timePtr);
+static void tcl_set_timer(const Tcl_Time *timePtr);
+static int tcl_wait_for_event(const Tcl_Time *timePtr);
 static void tcl_create_file_handler(int fd, int mask, Tcl_FileProc *proc, ClientData data);
 static void tcl_delete_file_handler(int fd);
 
 	tcl_file_handlers = g_hash_table_new(g_direct_hash, g_direct_equal);
 }
 
-static void tcl_set_timer(Tcl_Time *timePtr)
+static void tcl_set_timer(const Tcl_Time *timePtr)
 {
 	guint interval;
 
 	tcl_timer_pending = TRUE;
 }
 
-static int tcl_wait_for_event(Tcl_Time *timePtr)
+static int tcl_wait_for_event(const Tcl_Time *timePtr)
 {
 	if (!timePtr || (timePtr->sec == 0 && timePtr->usec == 0)) {
 		g_main_context_iteration(NULL, FALSE);

libpurple/protocols/gg/lib/events.c

 /**
  * \file events.c
  *
- * \brief Obsługa zdarzeń
+ * \brief Events Handling
  */
 
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+#include <ctype.h>
 #include <sys/types.h>
-#include <ctype.h>
+
+
+#ifdef GG_CONFIG_HAVE_GNUTLS
+#  include <gnutls/gnutls.h>
+#  include <gnutls/x509.h>
+#endif
+#ifdef GG_CONFIG_HAVE_OPENSSL
+#  include <openssl/err.h>
+#  include <openssl/x509.h>
+#endif
+
 
 #include "compat.h"
 #include "libgadu.h"
 #include "debug.h"
 #include "session.h"
 
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <time.h>
-#include <unistd.h>
-#include <ctype.h>
-#ifdef GG_CONFIG_HAVE_GNUTLS
-#  include <gnutls/gnutls.h>
-#  include <gnutls/x509.h>
-#endif
-#ifdef GG_CONFIG_HAVE_OPENSSL
-#  include <openssl/err.h>
-#  include <openssl/x509.h>
-#endif
-
 /**
  * Zwalnia pamięć zajmowaną przez informację o zdarzeniu.
  *

libpurple/protocols/gg/utils.c

 	GDate g_date;
 	static gchar buff[30];
 	
-	g_date_set_time(&g_date, date);
+	g_date_set_time_t(&g_date, date);
 	if (0 == g_date_strftime(buff, sizeof(buff), format, &g_date))
 		return NULL;
 	return buff;

pidgin/gtkaccount.c

 	gtk_widget_show(dialog->login_frame);
 
 	/* Main vbox */
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_container_add(GTK_CONTAINER(frame), vbox);
 	gtk_widget_show(vbox);
 
 	gtk_widget_show(dialog->user_frame);
 
 	/* Main vbox */
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_container_add(GTK_CONTAINER(frame), vbox);
 	gtk_widget_show(vbox);
 
 	gtk_widget_show(dialog->icon_check);
 	gtk_box_pack_start(GTK_BOX(vbox), dialog->icon_check, FALSE, FALSE, 0);
 
-	dialog->icon_hbox = hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	dialog->icon_hbox = hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_widget_set_sensitive(hbox, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)));
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 	gtk_widget_show(hbox);
 	purple_imgstore_unref(dialog->icon_img);
 	dialog->icon_img = NULL;
 
-	vbox2 = gtk_vbox_new(FALSE, 0);
+	vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 0);
 	gtk_widget_show(vbox2);
 
-	hbox2 = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, PIDGIN_HIG_BORDER);
 	gtk_widget_show(hbox2);
 
 	account = dialog->account;
 
 	/* Main vbox */
-	dialog->protocol_frame = vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	dialog->protocol_frame = vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BORDER);
 	gtk_notebook_insert_page(GTK_NOTEBOOK(dialog->notebook), vbox,
 			gtk_label_new_with_mnemonic(_("Ad_vanced")), 1);
 		gtk_widget_destroy(dialog->proxy_frame);
 
 	/* Main vbox */
-	dialog->proxy_frame = vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	dialog->proxy_frame = vbox = gtk_box_new(
+		GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE
+	);
 	gtk_container_add(GTK_CONTAINER(parent), vbox);
 	gtk_widget_show(vbox);
 
 	add_pref_box(dialog, vbox, _("Proxy _type:"), dialog->proxy_dropdown);
 
 	/* Setup the second vbox, which may be hidden at times. */
-	dialog->proxy_vbox = vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	dialog->proxy_vbox = vbox2 = gtk_box_new(
+		GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE
+	);
 	gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, FALSE, PIDGIN_HIG_BORDER);
 	gtk_widget_show(vbox2);
 
 	}
 
 	if (!dialog->voice_frame) {
-		dialog->voice_frame = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+		dialog->voice_frame = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 		gtk_container_set_border_width(GTK_CONTAINER(dialog->voice_frame),
 										PIDGIN_HIG_BORDER);
 
 	gtk_widget_show(GTK_WIDGET(notebook));
 
 	/* Setup the inner vbox */
-	dialog->top_vbox = vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+	dialog->top_vbox = vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 	gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BORDER);
 	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
 			gtk_label_new_with_mnemonic(_("_Basic")));
 	add_protocol_options(dialog);
 
 	/* Setup the page with 'Proxy'. */
-	dbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+	dbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 	gtk_container_set_border_width(GTK_CONTAINER(dbox), PIDGIN_HIG_BORDER);
 	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), dbox,
 			gtk_label_new_with_mnemonic(_("P_roxy")));

pidgin/gtkblist.c

 	                               PIDGIN_HIG_BOX_SPACE);
 	gtk_window_set_role(GTK_WINDOW(data->window), window_role);
 
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(data->window))),
 	                  hbox);
 	gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
 	gtk_misc_set_alignment(GTK_MISC(img), 0, 0);
 
-	vbox = gtk_vbox_new(FALSE, 5);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
 	gtk_container_add(GTK_CONTAINER(hbox), vbox);
 
 	label = gtk_label_new(label_text);
 			callback_func, filter_func, data);
 	pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("A_ccount"), data->sg, data->account_menu, TRUE, NULL);
 
-	data->vbox = GTK_BOX(gtk_vbox_new(FALSE, 5));
+	data->vbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
 	gtk_container_set_border_width(GTK_CONTAINER(data->vbox), 0);
 	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(data->vbox), FALSE, FALSE, 0);
 
 	const char *username = purple_account_get_username(account);
 	char *markup;
 
-	hbox = gtk_hbox_new(FALSE, 6);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
 	g_object_set_data(G_OBJECT(hbox), OBJECT_DATA_KEY_ACCOUNT, account);
 
 	pack_prpl_icon_start(hbox, account);
 static GtkWidget *
 kiosk_page()
 {
-	GtkWidget *ret = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	GtkWidget *ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	GtkWidget *label;
 	GtkWidget *entry;
 	GtkWidget *bbox;
 	label = gtk_label_new(" ");
 	gtk_box_pack_start(GTK_BOX(ret), label, FALSE, FALSE, 0);
 
-	bbox = gtk_hbutton_box_new();
+	bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
 	button = gtk_button_new_with_mnemonic(_("_Login"));
 	gtk_box_pack_start(GTK_BOX(ret), bbox, FALSE, FALSE, 0);
 	gtk_container_add(GTK_CONTAINER(bbox), button);
 	GTK_WINDOW(gtkblist->window)->allow_shrink = TRUE;
 #endif
 
-	gtkblist->main_vbox = gtk_vbox_new(FALSE, 0);
+	gtkblist->main_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_widget_show(gtkblist->main_vbox);
 	gtk_container_add(GTK_CONTAINER(gtkblist->window), gtkblist->main_vbox);
 
 	gtk_label_set_markup(GTK_LABEL(label), pretty);
 	g_free(pretty);
 	gtk_notebook_append_page(GTK_NOTEBOOK(gtkblist->notebook),label, NULL);
-	gtkblist->vbox = gtk_vbox_new(FALSE, 0);
+	gtkblist->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_notebook_append_page(GTK_NOTEBOOK(gtkblist->notebook), gtkblist->vbox, NULL);
 	gtk_widget_show_all(gtkblist->notebook);
 	pidgin_blist_select_notebook_page(gtkblist);
 
 	ebox = gtk_event_box_new();
 	gtk_box_pack_start(GTK_BOX(gtkblist->vbox), ebox, FALSE, FALSE, 0);
-	gtkblist->headline = gtk_hbox_new(FALSE, 3);
+	gtkblist->headline = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3);
 	gtk_container_set_border_width(GTK_CONTAINER(gtkblist->headline), 6);
 	gtk_container_add(GTK_CONTAINER(ebox), gtkblist->headline);
 	gtkblist->headline_image = gtk_image_new_from_pixbuf(NULL);
 		pidgin_make_scrollable(gtkblist->treeview, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_NONE, -1, -1), 
 		TRUE, TRUE, 0);
 
-	sep = gtk_hseparator_new();
+	sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
 	gtk_box_pack_start(GTK_BOX(gtkblist->vbox), sep, FALSE, FALSE, 0);
 
 	gtkblist->scrollbook = pidgin_scroll_book_new();

pidgin/gtkcertmgr.c

 	tpm_dat = g_new0(tls_peers_mgmt_data, 1);
 
 	tpm_dat->mgmt_widget = mgmt_widget =
-		gtk_hbox_new(FALSE, /* Non-homogeneous */
+		gtk_box_new(GTK_ORIENTATION_HORIZONTAL, /* Non-homogeneous */
 			     PIDGIN_HIG_BOX_SPACE);
 	gtk_container_set_border_width(GTK_CONTAINER(mgmt_widget),
 		PIDGIN_HIG_BOX_SPACE);
 		gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BOX_SPACE);
 
 		/* Setup the inner hbox and put the dialog's icon in it. */
-		hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 		gtk_container_add(GTK_CONTAINER(vbox), hbox);
 		gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
 		gtk_misc_set_alignment(GTK_MISC(img), 0, 0);
 
 		/* Setup the right vbox. */
-		vbox = gtk_vbox_new(FALSE, 0);
+		vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 		gtk_container_add(GTK_CONTAINER(hbox), vbox);
 
 		/* Put our happy label in it. */
 		gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 
 		/* hbox for the table, and to give it some spacing on the left. */
-		hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 		gtk_container_add(GTK_CONTAINER(vbox), hbox);
 
 		/* Setup the table we're going to use to lay stuff out. */
 	*group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem));
 
 	/* Do some evil, see some evil, speak some evil. */
-	box = gtk_hbox_new(FALSE, 0);
+	box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 
 	label = gtk_bin_get_child(GTK_BIN(menuitem));
 	g_object_ref(label);
 		GtkWidget *hbox, *label;
 		PidginChatPane *gtkchat = gtkconv->u.chat;
 
-		hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 		gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 
 		label = gtk_label_new(_("Topic:"));
 	PurpleConversation *conv = gtkconv->active_conv;
 
 	/* Build the right pane. */
-	lbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	lbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_paned_pack2(GTK_PANED(hpaned), lbox, FALSE, TRUE);
 	gtk_widget_show(lbox);
 
 static void
 pidgin_conv_setup_quickfind(PidginConversation *gtkconv, GtkWidget *container)
 {
-	GtkWidget *widget = gtk_hbox_new(FALSE, 0);
+	GtkWidget *widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 	GtkWidget *label, *entry, *close;
 
 	gtk_box_pack_start(GTK_BOX(container), widget, FALSE, FALSE, 0);
 	int buddyicon_size = 0;
 
 	/* Setup the top part of the pane */
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_widget_show(vbox);
 
 	/* Setup the info pane */
 	event_box = gtk_event_box_new();
 	gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), FALSE);
 	gtk_widget_show(event_box);
-	gtkconv->infopane_hbox = gtk_hbox_new(FALSE, 0);
+	gtkconv->infopane_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 	gtk_box_pack_start(GTK_BOX(vbox), event_box, FALSE, FALSE, 0);
 	gtk_container_add(GTK_CONTAINER(event_box), gtkconv->infopane_hbox);
 	gtk_widget_show(gtkconv->infopane_hbox);
 		   for both the buddy list and the chat window, but PidginConversation
 		   is pretty much stuck until 3.0. */
 		GtkWidget *sizing_vbox;
-		sizing_vbox = gtk_vbox_new(FALSE, 0);
+		sizing_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 		gtk_widget_set_size_request(sizing_vbox, -1, BUDDYICON_SIZE_MIN);
 		gtk_box_pack_start(GTK_BOX(gtkconv->infopane_hbox), sizing_vbox, FALSE, FALSE, 0);
 		gtk_widget_show(sizing_vbox);
 	}
 	else {
-		gtkconv->u.im->icon_container = gtk_vbox_new(FALSE, 0);
+		gtkconv->u.im->icon_container = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 
 		if ((buddy = purple_find_buddy(purple_conversation_get_account(conv),
 						purple_conversation_get_name(conv))) != NULL) {
 
 	pidgin_conv_setup_quickfind(gtkconv, vbox);
 
-	gtkconv->lower_hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	gtkconv->lower_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox), gtkconv->lower_hbox, FALSE, FALSE, 0);
 	gtk_widget_show(gtkconv->lower_hbox);
 
 	g_signal_connect(gtkconv->webview, "style-set", G_CALLBACK(set_typing_font), gtkconv);
 
 	/* Setup the container for the tab. */
-	gtkconv->tab_cont = tab_cont = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	gtkconv->tab_cont = tab_cont = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	g_object_set_data(G_OBJECT(tab_cont), "PidginConversation", gtkconv);
 	gtk_container_set_border_width(GTK_CONTAINER(tab_cont), PIDGIN_HIG_BOX_SPACE);
 	gtk_container_add(GTK_CONTAINER(tab_cont), pane);
 	img = gtk_image_new_from_stock(PIDGIN_STOCK_DIALOG_WARNING,
 	                               gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_HUGE));
 	/* Setup the inner hbox and put the dialog's icon in it. */
-	hbox = gtk_hbox_new(FALSE, 12);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);
 	gtk_container_add(GTK_CONTAINER(vbox), hbox);
 	gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
 	gtk_misc_set_alignment(GTK_MISC(img), 0, 0);
 
 	/* Setup the right vbox. */
-	vbox = gtk_vbox_new(FALSE, 12);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 12);
 	gtk_container_add(GTK_CONTAINER(hbox), vbox);
 
 	label = gtk_label_new(_("You have unread messages. Are you sure you want to close the window?"));
 	g_signal_connect(G_OBJECT(win->notebook), "button_release_event",
 	                 G_CALLBACK(notebook_release_cb), win);
 
-	testidea = gtk_vbox_new(FALSE, 0);
+	testidea = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 
 	/* Setup the menubar. */
 	menubar = setup_menubar(win);
 #endif
 	gtk_widget_set_name(gtkconv->tab_label, "tab-label");
 
-	gtkconv->menu_tabby = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	gtkconv->menu_tabby = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtkconv->menu_label = gtk_label_new(tmp_lab);
 	gtk_box_pack_start(GTK_BOX(gtkconv->menu_tabby), gtkconv->menu_icon, FALSE, FALSE, 0);
 
 #endif
 
 	if (angle)
-		gtkconv->tabby = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		gtkconv->tabby = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	else
-		gtkconv->tabby = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		gtkconv->tabby = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_widget_set_name(gtkconv->tabby, "tab-container");
 
 	/* select the correct ordering for verticle tabs */

pidgin/gtkdebug.c

 	handle = pidgin_debug_get_handle();
 
 	/* Setup the vbox */
-	vbox = gtk_vbox_new(FALSE, 0);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_container_add(GTK_CONTAINER(win->window), vbox);
 
 	if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/debug/toolbar")) {

pidgin/gtkdialogs.c

 	gtk_container_set_border_width(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(window))),
 	                               PIDGIN_HIG_BOX_SPACE);
 
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(window))), hbox);
 	img = gtk_image_new_from_stock(PIDGIN_STOCK_DIALOG_COOL, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_HUGE));
 	gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);

pidgin/gtkimhtml.c

 	GTK_IMHTML_SCALABLE(hr)->add_to = gtk_imhtml_hr_add_to;
 	GTK_IMHTML_SCALABLE(hr)->free = gtk_imhtml_hr_free;
 
-	hr->sep = gtk_hseparator_new();
+	hr->sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
 	gtk_widget_set_size_request(hr->sep, 5000, 2);
 	gtk_widget_show(hr->sep);
 

pidgin/gtkimhtmltoolbar.c

 	if (!list)
 		return;
 
-	line = gtk_hbox_new(FALSE, 0);
+	line = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 	gtk_box_pack_start(GTK_BOX(container), line, FALSE, FALSE, 0);
 	for (; list; list = list->next) {
 		if (custom != !!(list->smiley->flags & GTK_IMHTML_SMILEY_CUSTOM))
 		line_width += list->width;
 		if (line_width >= max_width) {
 			if (list->next) {
-				line = gtk_hbox_new(FALSE, 0);
+				line = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 				gtk_box_pack_start(GTK_BOX(container), line, FALSE, FALSE, 0);
 			}
 			line_width = 0;
 		ls = NULL;
 		max_line_width = 0;
 		num_lines = floor(sqrt(g_slist_length(unique_smileys)));
-		smiley_table = gtk_vbox_new(FALSE, 0);
+		smiley_table = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 
 		if (supports_custom) {
 			GtkWidget *manage = gtk_button_new_with_mnemonic(_("_Manage custom smileys"));
 		/* pack buttons of the list */
 		add_smiley_list(smiley_table, ls, max_line_width, FALSE);
 		if (supports_custom) {
-			gtk_box_pack_start(GTK_BOX(smiley_table), gtk_hseparator_new(), TRUE, FALSE, 0);
+			gtk_box_pack_start(GTK_BOX(smiley_table), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), TRUE, FALSE, 0);
 			add_smiley_list(smiley_table, ls, max_line_width, TRUE);
 		}
 		while (ls) {
 	};
 	int iter;
 
-	hbox = gtk_hbox_new(FALSE, 0);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 
 	for (iter = 0; buttons[iter].stock; iter++) {
 		if (buttons[iter].stock[0]) {
 			*(buttons[iter].button) = button;
 			gtk_widget_set_tooltip_text(button, buttons[iter].tooltip);
 		} else
-			button = gtk_vseparator_new();
+			button = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
 		gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
 	}
 
 static void gtk_imhtmltoolbar_init (GtkIMHtmlToolbar *toolbar)
 {
 	GtkWidget *hbox = GTK_WIDGET(toolbar), *event = gtk_event_box_new();
-	GtkWidget *bbox, *box = gtk_hbox_new(FALSE, 0);
+	GtkWidget *bbox, *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 	GtkWidget *image;
 	GtkWidget *label;
 	GtkWidget *insert_button;
 	/* Fonts */
 	font_button = gtk_toggle_button_new();
 	gtk_button_set_relief(GTK_BUTTON(font_button), GTK_RELIEF_NONE);
-	bbox = gtk_hbox_new(FALSE, 3);
+	bbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3);
 	gtk_container_add(GTK_CONTAINER(font_button), bbox);
 	image = gtk_image_new_from_stock(GTK_STOCK_BOLD, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL));
 	gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
 	                      g_object_ref(font_button), (GClosureNotify)g_object_unref, 0);
 
 	/* Sep */
-	sep = gtk_vseparator_new();
+	sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
 	gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0);
 	gtk_widget_show_all(sep);
 
 	/* Insert */
 	insert_button = gtk_toggle_button_new();
 	gtk_button_set_relief(GTK_BUTTON(insert_button), GTK_RELIEF_NONE);
-	bbox = gtk_hbox_new(FALSE, 3);
+	bbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3);
 	gtk_container_add(GTK_CONTAINER(insert_button), bbox);
 	image = gtk_image_new_from_stock(PIDGIN_STOCK_TOOLBAR_INSERT, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL));
 	gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
 	toolbar->sml = NULL;
 
 	/* Sep */
-	sep = gtk_vseparator_new();
+	sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
 	gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0);
 	gtk_widget_show_all(sep);
 
 	/* Smiley */
 	smiley_button = gtk_button_new();
 	gtk_button_set_relief(GTK_BUTTON(smiley_button), GTK_RELIEF_NONE);
-	bbox = gtk_hbox_new(FALSE, 3);
+	bbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3);
 	gtk_container_add(GTK_CONTAINER(smiley_button), bbox);
 	image = gtk_image_new_from_stock(PIDGIN_STOCK_TOOLBAR_SMILEY, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL));
 	gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
 	gtk_widget_show_all(smiley_button);
 
 	/* Sep */
-	sep = gtk_vseparator_new();
+	sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
 	gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0);
 	gtk_widget_show_all(sep);
 
 	/* Attention */
 	attention_button = gtk_button_new();
 	gtk_button_set_relief(GTK_BUTTON(attention_button), GTK_RELIEF_NONE);
-	bbox = gtk_hbox_new(FALSE, 3);
+	bbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3);
 	gtk_container_add(GTK_CONTAINER(attention_button), bbox);
 	image = gtk_image_new_from_stock(PIDGIN_STOCK_TOOLBAR_SEND_ATTENTION,
 		gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL));
 
 	/* Icon *************/
 	if (icon != NULL) {
-		title_box = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		title_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 		gtk_container_set_border_width(GTK_CONTAINER(title_box), PIDGIN_HIG_BOX_SPACE);
 		gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(lv->window))),
 		                   title_box, FALSE, FALSE, 0);
 	}
 
 	/* A fancy little box ************/
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_paned_add2(GTK_PANED(pane), vbox);
 
 	/* Viewer ************/
 	gtk_widget_show(frame);
 
 	/* Search box **********/
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 	lv->entry = gtk_entry_new();
 	gtk_box_pack_start(GTK_BOX(hbox), lv->entry, TRUE, TRUE, 0);

pidgin/gtkmedia.c

 	XSetErrorHandler(pidgin_x_error_handler);
 #endif
 
-	vbox = gtk_vbox_new(FALSE, 0);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_container_add(GTK_CONTAINER(media), vbox);
 
 	media->priv->statusbar = gtk_statusbar_new();
 	gtk_box_pack_start(GTK_BOX(vbox), media->priv->menubar,
 			FALSE, TRUE, 0);
 
-	media->priv->display = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	media->priv->display = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_container_set_border_width(GTK_CONTAINER(media->priv->display),
 			PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox), media->priv->display,
 
 #if GTK_CHECK_VERSION(2,12,0)
 	/* Setup widget structure */
-	volume_widget = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
-	progress_parent = gtk_vbox_new(FALSE, 0);
+	volume_widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
+	progress_parent = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_box_pack_start(GTK_BOX(volume_widget),
 			progress_parent, TRUE, TRUE, 0);
 
 			volume, FALSE, FALSE, 0);
 #else
 	/* Setup widget structure */
-	volume_widget = gtk_vbox_new(FALSE, 0);
+	volume_widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	progress_parent = volume_widget;
 
 	/* Volume slider */
 	if (gtkmedia->priv->recv_widget == NULL
 			&& type & (PURPLE_MEDIA_RECV_VIDEO |
 			PURPLE_MEDIA_RECV_AUDIO)) {
-		recv_widget = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		recv_widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 		gtk_box_pack_start(GTK_BOX(gtkmedia->priv->display),
 				recv_widget, TRUE, TRUE, 0);
 		gtk_widget_show(recv_widget);
 	if (gtkmedia->priv->send_widget == NULL
 			&& type & (PURPLE_MEDIA_SEND_VIDEO |
 			PURPLE_MEDIA_SEND_AUDIO)) {
-		send_widget = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		send_widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 		gtk_box_pack_start(GTK_BOX(gtkmedia->priv->display),
 				send_widget, FALSE, TRUE, 0);
-		button_widget = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		button_widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 		gtk_box_pack_end(GTK_BOX(recv_widget), button_widget,
 				FALSE, TRUE, 0);
 		gtk_widget_show(send_widget);

pidgin/gtkmenutray.c

 	gtk_menu_item_set_right_justified(GTK_MENU_ITEM(menu_tray), TRUE);
 
 	if(!GTK_IS_WIDGET(menu_tray->tray))
-		menu_tray->tray = gtk_hbox_new(FALSE, 0);
+		menu_tray->tray = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 
 	settings =
 		gtk_settings_get_for_screen(gtk_widget_get_screen(widget));

pidgin/gtknotify.c

 	gtk_container_set_border_width(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
 	                               PIDGIN_HIG_BOX_SPACE);
 
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
 	                  hbox);
 

pidgin/gtkplugin.c

 static GtkWidget *
 create_details()
 {
-	GtkBox *vbox = GTK_BOX(gtk_vbox_new(FALSE, 3));
+	GtkBox *vbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 3));
 	GtkSizeGroup *sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 	GtkWidget *label, *view, *website_button;
 

pidgin/gtkpluginpref.c

 				GtkWidget *toolbar;
 				GtkWidget *frame;
 
-				box = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+				box = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 
 				gtk_widget_show(box);
 				gtk_box_pack_start(GTK_BOX(parent), box, FALSE, FALSE, 0);
 				if(sg)
 					gtk_size_group_add_widget(sg, gtk_label);
 
-				hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+				hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 				gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
 				gtk_widget_show(hbox);
 
 
 	sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 
-	parent = ret = gtk_vbox_new(FALSE, 16);
+	parent = ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, 16);
 #if !GTK_CHECK_VERSION(3,0,0)
 	gtk_container_set_border_width(GTK_CONTAINER(ret), PIDGIN_HIG_BORDER);
 #endif

pidgin/gtkpounce.c

 	vbox1 = gtk_dialog_get_content_area(GTK_DIALOG(window));
 
 	/* Create the vbox that will contain all the prefs stuff. */
-	vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox1), vbox2, TRUE, TRUE, 0);
 
 	/* Create the "Pounce on Whom" frame. */
 	frame = pidgin_make_frame(vbox2, _("Pounce on Whom"));
 
 	/* Account: */
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(frame), hbox, FALSE, FALSE, 0);
 	gtk_widget_show(hbox);
 
 	pidgin_set_accessible_label (dialog->account_menu, label);
 
 	/* Buddy: */
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(frame), hbox, FALSE, FALSE, 0);
 	gtk_widget_show(hbox);
 

pidgin/gtkprefs.c

 {
 	GtkWidget *label;
 	GtkWidget *combo_box = NULL;
-	GtkWidget *themesel_hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	GtkWidget *themesel_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 
 	label = gtk_label_new(label_str);
 	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 	GtkWidget *themesel_hbox;
 	GtkCellRenderer *cell_rend;
 
-	themesel_hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	themesel_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox), themesel_hbox, FALSE, FALSE, 0);
 
 	label = gtk_label_new(label_str);
 	GtkSizeGroup *label_sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 	GtkSizeGroup *combo_sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 
-	ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER);
 
 	vbox = pidgin_make_frame(ret, _("Theme Selections"));
 	GtkSizeGroup *sg;
 	GList *names = NULL;
 
-	ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width(GTK_CONTAINER(ret), PIDGIN_HIG_BORDER);
 
 	sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 	 * Connect a signal to the above preference.  When conversations are not
 	 * shown in a tabbed window then all tabbing options should be disabled.
 	 */
-	vbox2 = gtk_vbox_new(FALSE, 9);
+	vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 9);
 	gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, FALSE, 0);
 	purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/conversations/tabs",
 	                            conversation_usetabs_cb, vbox2);
 	GtkWidget *checkbox;
 	GtkWidget *spin_button;
 
-	ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width(GTK_CONTAINER(ret), PIDGIN_HIG_BORDER);
 
 	vbox = pidgin_make_frame(ret, _("Conversations"));
 #ifdef _WIN32
 	pidgin_prefs_checkbox(_("F_lash window when IMs are received"), PIDGIN_PREFS_ROOT "/win32/blink_im", vbox);
 #endif
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 
 	checkbox = pidgin_prefs_checkbox(_("Resize incoming custom smileys"),
 			PIDGIN_PREFS_ROOT "/conversations/resize_custom_smileys", hbox);
 	GtkWidget *label, *auto_ip_checkbox, *ports_checkbox, *spin_button;
 	GtkSizeGroup *sg;
 
-	ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER);
 
 	vbox = pidgin_make_frame (ret, _("IP Address"));
 	pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("ST_UN server:"),
 			sg, entry, TRUE, NULL);
 
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_container_add(GTK_CONTAINER(vbox), hbox);
 
 	label = gtk_label_new(NULL);
 	pidgin_prefs_checkbox(_("_Enable automatic router port forwarding"),
 			"/purple/network/map_ports", vbox);
 
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 
 	ports_checkbox = pidgin_prefs_checkbox(_("_Manually specify range of ports to listen on:"),
 			"/purple/network/ports_range_use", hbox);
 	GtkSizeGroup *sg;
 	GList *browsers = NULL;
 
-	ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER);
 
 	vbox = pidgin_make_frame (ret, _("Browser Selection"));
 	if (purple_running_gnome()) {
 		gchar *path;
 
-		hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 		label = gtk_label_new(_("Browser preferences are configured in GNOME preferences"));
 		gtk_container_add(GTK_CONTAINER(vbox), hbox);
 		gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 
-		hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 		gtk_container_add(GTK_CONTAINER(vbox), hbox);
 
 		path = g_find_program_in_path("gnome-control-center");
 			gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 			gtk_size_group_add_widget(sg, label);
 
-			hbox = gtk_hbox_new(FALSE, 0);
+			hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 			label = pidgin_prefs_dropdown(hbox, _("_Open link in:"), PURPLE_PREF_INT,
 				PIDGIN_PREFS_ROOT "/browsers/place",
 				_("Browser default"), PIDGIN_BROWSER_DEFAULT,
 	GtkWidget *prefs_proxy_frame = NULL;
 	PurpleProxyInfo *proxy_info;
 
-	ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width(GTK_CONTAINER(ret), PIDGIN_HIG_BORDER);
 	vbox = pidgin_make_frame(ret, _("Proxy Server"));
-	prefs_proxy_frame = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	prefs_proxy_frame = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 
 	if(purple_running_gnome()) {
 		gchar *path = NULL;
 
-		hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 		label = gtk_label_new(_("Proxy preferences are configured in GNOME preferences"));
 		gtk_container_add(GTK_CONTAINER(vbox), hbox);
 		gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 
-		hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 		gtk_container_add(GTK_CONTAINER(vbox), hbox);
 
 		path = g_find_program_in_path("gnome-network-properties");
 		         which is never */
 		gtk_widget_show_all(ret);
 	} else {
-		GtkWidget *prefs_proxy_subframe = gtk_vbox_new(FALSE, 0);
+		GtkWidget *prefs_proxy_subframe = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 
 		/* This is a global option that affects SOCKS4 usage even with
 		 * account-specific proxy settings */
 	GtkWidget *vbox;
 	GList *names;
 
-	ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER);
 
 
 	const char *cmd;
 #endif
 
-	ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER);
 
 	sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 
 	vbox2 = pidgin_make_frame(ret, _("Sound Options"));
 
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox2), vbox, FALSE, FALSE, 0);
 
 #ifndef _WIN32
 		pidgin_make_scrollable(event_view, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, 100),
 		TRUE, TRUE, 0);
 
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 	sound_entry = gtk_entry_new();
 	pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s",
 	GtkWidget *menu;
 	GtkSizeGroup *sg;
 
-	ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER);
 
 	sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 			_("_Minutes before becoming idle:"), "/purple/away/mins_before_away",
 			1, 24 * 60, sg);
 
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 
 	button = pidgin_prefs_checkbox(_("Change to this status when _idle:"),
 	label = gtk_label_new(NULL);
 	gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
 
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 	label = gtk_label_new(_("Volume:"));
 	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 	GtkWidget *vbox;
 	GtkSizeGroup *sg;
 
-	ret = gtk_hbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width(GTK_CONTAINER(ret), PIDGIN_HIG_BORDER);
 
 	sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);

pidgin/gtkrequest.c

 	                    PIDGIN_HIG_BORDER);
 
 	/* Setup the main horizontal box */
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
 	                  hbox);
 
 	gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
 
 	/* Vertical box */
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 
 	gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
 
 	                    PIDGIN_HIG_BORDER);
 
 	/* Setup the main horizontal box */
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
 	                  hbox);
 
 	pidgin_widget_decorate_account(hbox, account);
 
 	/* Vertical box */
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 	gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
 
 	/* Descriptive label */
 
 	g_free(label_text);
 
-	vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, FALSE, 0);
 	while ((radio_text = va_arg(args, char*))) {
 		       int resp = va_arg(args, int);
 	                    PIDGIN_HIG_BORDER);
 
 	/* Setup the main horizontal box */
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
 	                  hbox);
 
 	gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
 
 	/* Vertical box */
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 	gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
 
 	pidgin_widget_decorate_account(hbox, account);
 		gint i;
 
 		if (num_labels == 2)
-			box = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+			box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 		else
-			box = gtk_vbox_new(FALSE, 0);
+			box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 
 		widget = box;
 
 					 G_CALLBACK(destroy_multifield_cb), data);
 
 	/* Setup the main horizontal box */
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(pidgin_dialog_get_vbox(GTK_DIALOG(win))), hbox);
 	gtk_widget_show(hbox);
 
 	pidgin_widget_decorate_account(hbox, account);
 
 	/* Setup the vbox */
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 	gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
 	gtk_widget_show(vbox);
 
 	if(total_fields > 9) {
 		GtkWidget *hbox_for_spacing, *vbox_for_spacing;
 
-		hbox_for_spacing = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+		hbox_for_spacing = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 		gtk_box_pack_start(GTK_BOX(vbox), 
 			pidgin_make_scrollable(hbox_for_spacing, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, GTK_SHADOW_NONE, -1, 200), 
 			TRUE, TRUE, 0);
 		gtk_widget_show(hbox_for_spacing);
 
-		vbox_for_spacing = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+		vbox_for_spacing = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 		gtk_box_pack_start(GTK_BOX(hbox_for_spacing),
 				vbox_for_spacing, TRUE, TRUE, PIDGIN_HIG_BOX_SPACE);
 		gtk_widget_show(vbox_for_spacing);
 
-		vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+		vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 		gtk_box_pack_start(GTK_BOX(vbox_for_spacing),
 				vbox2, TRUE, TRUE, PIDGIN_HIG_BOX_SPACE);
 		gtk_widget_show(vbox2);

pidgin/gtkroomlist.c

 	/* Create the parent vbox for everything. */
 	vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(window), FALSE, PIDGIN_HIG_BORDER);
 
-	vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+	vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(vbox), vbox2);
 	gtk_widget_show(vbox2);
 

pidgin/gtksavedstatuses.c

 	gtk_box_pack_start(GTK_BOX(vbox), expander, FALSE, FALSE, 0);
 
 	/* Setup the box that the expander will cover */
-	dbox = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	dbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_add(GTK_CONTAINER(expander), dbox);
 
 	/* Create the list model */
 	sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 
 	/* Status type */
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 
 	label = gtk_label_new_with_mnemonic(_("_Status:"));
 	gtk_box_pack_start(GTK_BOX(hbox), combo, FALSE, FALSE, 0);
 
 	/* Status mesage */
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
 
 	label = gtk_label_new_with_mnemonic(_("_Message:"));

pidgin/gtkscrollbook.c

 	GtkWidget *eb;
 	GtkWidget *close_button;
 
-	scroll_book->hbox = gtk_hbox_new(FALSE, 0);
+	scroll_book->hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 
 	/* Close */
 	eb = gtk_event_box_new();

pidgin/gtksmiley.c

 	vbox = gtk_grid_new();
 	gtk_grid_set_row_spacing(GTK_GRID(vbox), PIDGIN_HIG_BORDER);
 #else
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 #endif
 	gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(window))),
                     vbox);
 	gtk_grid_set_column_spacing(GTK_GRID(hbox), PIDGIN_HIG_BORDER);
 	gtk_grid_attach(GTK_GRID(vbox), hbox, 0, 0, 1, 1);
 #else
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(GTK_VBOX(vbox)), hbox);
 #endif
 
 
 	gtk_grid_attach_next_to(GTK_GRID(vbox), hbox, NULL, GTK_POS_BOTTOM, 1, 1);
 #else
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(GTK_VBOX(vbox)),hbox);
 #endif
 

pidgin/gtkstatusbox.c

 	status_box->connecting = FALSE;
 	status_box->typing = 0;
 	status_box->toggle_button = gtk_toggle_button_new();
-	status_box->hbox = gtk_hbox_new(FALSE, 6);
+	status_box->hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
 	status_box->cell_view = gtk_cell_view_new();
-	status_box->vsep = gtk_vseparator_new();
+	status_box->vsep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
 	status_box->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
 
 	status_box->store = gtk_list_store_new(NUM_COLUMNS, G_TYPE_INT, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
 	gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(status_box->cell_view), emblem_rend, "pixbuf", EMBLEM_COLUMN, "visible", EMBLEM_VISIBLE_COLUMN, NULL);
 	g_object_set(status_box->text_rend, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 
-	status_box->vbox = gtk_vbox_new(0, FALSE);
+	status_box->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	status_box->sw = pidgin_create_webview(FALSE, &status_box->webview, NULL, NULL);
 	gtk_webview_set_editable(GTK_WEBVIEW(status_box->webview), TRUE);
 

pidgin/gtkutils.c

 	frame = gtk_frame_new(NULL);
 	gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
 
-	vbox = gtk_vbox_new(FALSE, 0);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_container_add(GTK_CONTAINER(frame), vbox);
 	gtk_widget_show(vbox);
 
 		gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
 		gtk_widget_show(toolbar);
 
-		sep = gtk_hseparator_new();
+		sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
 		gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0);
 		g_signal_connect_swapped(G_OBJECT(toolbar), "show", G_CALLBACK(gtk_widget_show), sep);
 		g_signal_connect_swapped(G_OBJECT(toolbar), "hide", G_CALLBACK(gtk_widget_hide), sep);
 	button = gtk_toggle_button_new();
 	gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
 
-	bbox = gtk_vbox_new(FALSE, 0);
+	bbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 
 	gtk_container_add (GTK_CONTAINER(button), bbox);
 
 	button = gtk_button_new();
 
 	if (style == PIDGIN_BUTTON_HORIZONTAL) {
-		bbox = gtk_hbox_new(FALSE, 0);
-		ibox = gtk_hbox_new(FALSE, 0);
+		bbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+		ibox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 		if (text)
-			lbox = gtk_hbox_new(FALSE, 0);
+			lbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 	} else {
-		bbox = gtk_vbox_new(FALSE, 0);
-		ibox = gtk_vbox_new(FALSE, 0);
+		bbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+		ibox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 		if (text)
-			lbox = gtk_vbox_new(FALSE, 0);
+			lbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	}
 
 	gtk_container_add(GTK_CONTAINER(button), bbox);
 	GtkWidget *vbox, *label, *hbox;
 	char *labeltitle;
 
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(parent), vbox, FALSE, FALSE, 0);
 	gtk_widget_show(vbox);
 
 	gtk_widget_show(label);
 	pidgin_set_accessible_label (vbox, label);
 
-	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 	gtk_widget_show(hbox);
 
 	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 	gtk_widget_show(label);
 
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
 	gtk_widget_show(vbox);
 
 	dialog->icon_preview = gtk_image_new();
 	dialog->icon_text = gtk_label_new(NULL);
 
-	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 	gtk_widget_set_size_request(GTK_WIDGET(vbox), -1, 50);
 	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(dialog->icon_preview), TRUE, FALSE, 0);
 	gtk_box_pack_end(GTK_BOX(vbox), GTK_WIDGET(dialog->icon_text), FALSE, FALSE, 0);
 	GtkWidget *label = NULL;
 
 	if (widget_label) {
-		hbox = gtk_hbox_new(FALSE, 5);
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
 		gtk_widget_show(hbox);
 		gtk_box_pack_start(vbox, hbox, FALSE, FALSE, 0);
 

pidgin/gtkwebviewtoolbar.c

 	if (!list)
 		return;
 
-	line = gtk_hbox_new(FALSE, 0);
+	line = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 	gtk_box_pack_start(GTK_BOX(container), line, FALSE, FALSE, 0);
 	for (; list; list = list->next) {
 		if (custom != !!(gtk_webview_smiley_get_flags(list->smiley) & GTK_WEBVIEW_SMILEY_CUSTOM))
 		line_width += list->width;
 		if (line_width >= max_width) {
 			if (list->next) {
-				line = gtk_hbox_new(FALSE, 0);
+				line = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 				gtk_box_pack_start(GTK_BOX(container), line, FALSE, FALSE, 0);
 			}
 			line_width = 0;
 		ls = NULL;
 		max_line_width = 0;
 		num_lines = floor(sqrt(g_slist_length(unique_smileys)));
-		smiley_table = gtk_vbox_new(FALSE, 0);
+		smiley_table = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 
 		if (supports_custom) {
 			GtkWidget *manage = gtk_button_new_with_mnemonic(_("_Manage custom smileys"));
 		/* pack buttons of the list */
 		add_smiley_list(smiley_table, ls, max_line_width, FALSE);
 		if (supports_custom) {
-			gtk_box_pack_start(GTK_BOX(smiley_table), gtk_hseparator_new(), TRUE, FALSE, 0);
+			gtk_box_pack_start(GTK_BOX(smiley_table), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), TRUE, FALSE, 0);
 			add_smiley_list(smiley_table, ls, max_line_width, TRUE);
 		}
 		while (ls) {

pidgin/gtkwhiteboard.c

 	GtkWidget *palette_color_box[PALETTE_NUM_COLORS];
 
 	/* Create vertical box to place palette above the canvas and controls */
-	vbox_palette_above_canvas_and_controls = gtk_vbox_new(FALSE, 0);
+	vbox_palette_above_canvas_and_controls = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_container_add(GTK_CONTAINER(window), vbox_palette_above_canvas_and_controls);
 	gtk_widget_show(vbox_palette_above_canvas_and_controls);
 
 	/* Create horizontal box for the palette and all its entries */
-	hbox_palette = gtk_hbox_new(FALSE, 0);
+	hbox_palette = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 	gtk_box_pack_start(GTK_BOX(vbox_palette_above_canvas_and_controls),
 			hbox_palette, FALSE, FALSE, PIDGIN_HIG_BORDER);
 	gtk_widget_show(hbox_palette);
 
 	/* Create horizontal box to seperate the canvas from the controls */
-	hbox_canvas_and_controls = gtk_hbox_new(FALSE, 0);
+	hbox_canvas_and_controls = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 	gtk_box_pack_start(GTK_BOX(vbox_palette_above_canvas_and_controls),
 			hbox_canvas_and_controls, FALSE, FALSE, PIDGIN_HIG_BORDER);
 	gtk_widget_show(hbox_canvas_and_controls);
 	}
 #endif
 
-	hbox_canvas_and_controls = gtk_hbox_new(FALSE, 0);
+	hbox_canvas_and_controls = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 	gtk_widget_show(hbox_canvas_and_controls);
 
 	gtk_container_add(GTK_CONTAINER(window), hbox_canvas_and_controls);
 						  GDK_POINTER_MOTION_HINT_MASK);
 
 	/* Create vertical box to contain the controls */
-	vbox_controls = gtk_vbox_new(FALSE, 0);
+	vbox_controls = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_box_pack_start(GTK_BOX(hbox_canvas_and_controls),
 					vbox_controls, FALSE, FALSE, PIDGIN_HIG_BOX_SPACE);
 	gtk_widget_show(vbox_controls);

pidgin/minidialog.c

 
 	gtk_container_set_border_width(GTK_CONTAINER(self), PIDGIN_HIG_BOX_SPACE);
 
-	priv->title_box = GTK_BOX(gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE));
+	priv->title_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE));
 
 	priv->icon = GTK_IMAGE(gtk_image_new());
 	gtk_misc_set_alignment(GTK_MISC(priv->icon), 0, 0);
 		blist_width_changed_cb, self);
 #endif
 
-	self->contents = GTK_BOX(gtk_vbox_new(FALSE, 0));
+	self->contents = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
 
-	priv->buttons = GTK_BOX(gtk_hbox_new(FALSE, 0));
+	priv->buttons = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
 
 	gtk_box_pack_start(self_box, GTK_WIDGET(priv->title_box), FALSE, FALSE, 0);
 	gtk_box_pack_start(self_box, GTK_WIDGET(priv->desc), FALSE, FALSE, 0);

pidgin/plugins/cap/cap.c

 static CapPrefsUI * create_cap_prefs_ui() {
 	CapPrefsUI *ui = g_malloc(sizeof(CapPrefsUI));
 
-	ui->ret = gtk_vbox_new(FALSE, 18);
+	ui->ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, 18);
 	gtk_container_set_border_width(GTK_CONTAINER(ui->ret), 10);
 	ui->cap_vbox = pidgin_make_frame(ui->ret, _("Statistics Configuration"));
 

pidgin/plugins/contact_priority.c

 
 	sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 
-	ret = gtk_vbox_new(FALSE, 18);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, 18);
 	gtk_container_set_border_width(GTK_CONTAINER(ret), 12);
 
 	frame = pidgin_make_frame(ret, _("Point values to use when..."));
 
-	vbox = gtk_vbox_new(FALSE, 5);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
 	gtk_container_add(GTK_CONTAINER(frame), vbox);
 
 	/* Status Spinboxes */
 	{
 		char *pref = g_strconcat("/purple/status/scores/", statuses[i].id, NULL);
 
-		hbox = gtk_hbox_new(FALSE, 5);
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
 		gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 
 		label = gtk_label_new_with_mnemonic(_(statuses[i].description));
 	gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 
 	/* Last match */
-	hbox = gtk_hbox_new(FALSE, 5);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 
 	check = gtk_check_button_new_with_label(_("Use last buddy when scores are equal"));
 
 	frame = pidgin_make_frame(ret, _("Point values to use for account..."));
 
-	vbox = gtk_vbox_new(FALSE, 5);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
 	gtk_container_add(GTK_CONTAINER(frame), vbox);
 
 	/* Account */
-	hbox = gtk_hbox_new(FALSE, 5);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 
 	/* make this here so I can use it in the option menu callback, we'll

pidgin/plugins/convcolors.c

 	GtkWidget *frame;
 	int i;
 
-	ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_CAT_SPACE);
 	gtk_container_set_border_width(GTK_CONTAINER(ret), PIDGIN_HIG_BORDER);
 
 	for (i = 0; formats[i].prefix; i++)
 		f = purple_prefs_get_int(tmp);
 
 		frame = pidgin_make_frame(ret, _(formats[i].text));
-		vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
 		gtk_box_pack_start(GTK_BOX(frame), vbox, FALSE, FALSE, 0);
 
-		hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
 		gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 
 		button = gtk_check_button_new_with_label(_("Enabled"));

pidgin/plugins/crazychat/cc_gtk_gl.c

 	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 	gtk_container_set_reallocate_redraws(GTK_CONTAINER(window), TRUE);
 
-	vbox = gtk_vbox_new(FALSE, 0);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_container_add(GTK_CONTAINER(window), vbox);
 	gtk_widget_show(vbox);
 

pidgin/plugins/crazychat/cc_pidgin_plugin.c

 	/* create widgets */
 
 	/* creating the config frame */
-	ret = gtk_vbox_new(FALSE, 18);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, 18);
 	gtk_container_set_border_width(GTK_CONTAINER(ret), 12);
 
 	/* make the network configuration frame */
 	gtk_widget_show(frame);
 
 	/* add boxes for packing purposes */
-	vbox = gtk_vbox_new(FALSE, 0);
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 	gtk_box_pack_start(GTK_BOX(frame), vbox, TRUE, TRUE, 0);
 	gtk_widget_show(vbox);
 
 	/* add widgets to row 1 */
-	hbox = gtk_hbox_new(FALSE, 0);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 	gtk_widget_show(hbox);
 	label = gtk_label_new(_("TCP port"));

pidgin/plugins/disco/gtkdisco.c

 	/* Create the parent vbox for everything. */
 	vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(window), FALSE, PIDGIN_HIG_BORDER);
 
-	vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);
+	vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
 	gtk_container_add(GTK_CONTAINER(vbox), vbox2);
 	gtk_widget_show(vbox2);
 

pidgin/plugins/gestures/gestures.c

 #endif
 
 	/* Outside container */
-	ret = gtk_vbox_new(FALSE, 18);
+	ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, 18);
 	gtk_container_set_border_width(GTK_CONTAINER(ret), 12);
 
 	/* Configuration frame */

pidgin/plugins/gevolution/add_buddy_dialog.c

 					 G_CALLBACK(delete_win_cb), dialog);
 
 	/* Setup the vbox */
-	vbox = gtk_vbox_new(FALSE, 12);