diff --git a/plugins/vnc/vinagre-vnc-tab.c b/plugins/vnc/vinagre-vnc-tab.c
index f26a799..cb8f5d6 100644
--- a/plugins/vnc/vinagre-vnc-tab.c
+++ b/plugins/vnc/vinagre-vnc-tab.c
@@ -576,7 +576,7 @@ vnc_pointer_ungrab_cb (VncDisplay *vnc, VinagreVncTab *vnc_tab)
 static void
 vnc_bell_cb (VncDisplay *vnc, VinagreVncTab *vnc_tab)
 {
-  gdk_window_beep (GTK_WIDGET (vnc_tab)->window);
+  gdk_window_beep (gtk_widget_get_window (GTK_WIDGET (vnc_tab)));
 }
 
 static void
diff --git a/vinagre/view/autoDrawer.c b/vinagre/view/autoDrawer.c
index ccafedc..ca1e5ef 100644
--- a/vinagre/view/autoDrawer.c
+++ b/vinagre/view/autoDrawer.c
@@ -81,6 +81,7 @@ ViewAutoDrawerEnforce(ViewAutoDrawer *that, // IN
 {
    double fraction;
    ViewAutoDrawerPrivate *priv = that->priv;
+   GtkAllocation allocation;
 
    if (!priv->active) {
       ViewOvBox_SetMin(VIEW_OV_BOX(that), -1);
@@ -92,8 +93,9 @@ ViewAutoDrawerEnforce(ViewAutoDrawer *that, // IN
    g_assert(GTK_IS_WIDGET(priv->over));
 
    ViewOvBox_SetMin(VIEW_OV_BOX(that), priv->noOverlapPixels);
+   gtk_widget_get_allocation (priv->over, &allocation);
    fraction = priv->opened
-      ? 1 : ((double)priv->overlapPixels / priv->over->allocation.height);
+      ? 1 : ((double)priv->overlapPixels / allocation.height);
    if (!animate) {
       ViewOvBox_SetFraction(VIEW_OV_BOX(that), fraction);
    }
@@ -179,12 +181,14 @@ ViewAutoDrawerUpdate(ViewAutoDrawer *that, // IN
    {
       int x;
       int y;
+      GtkAllocation allocation;
 
       gtk_widget_get_pointer(priv->evBox, &x, &y);
+      gtk_widget_get_allocation(priv->evBox, &allocation);
       g_assert(gtk_container_get_border_width(   GTK_CONTAINER(priv->evBox))
                                               == 0);
-      if (   (guint)x < (guint)priv->evBox->allocation.width
-          && (guint)y < (guint)priv->evBox->allocation.height) {
+      if (   (guint)x < (guint)allocation.width
+          && (guint)y < (guint)allocation.height) {
          priv->opened = TRUE;
       }
    }
@@ -210,10 +214,14 @@ ViewAutoDrawerUpdate(ViewAutoDrawer *that, // IN
 
    if (!priv->inputUngrabbed) {
       GtkWidget *grabbed = NULL;
-
-      if (window->group && window->group->grabs) {
-         grabbed = GTK_WIDGET(window->group->grabs->data);
-      }
+      GtkWindowGroup *group;
+
+      group = gtk_window_get_group (window);
+      //HACK: missing accessor?
+      grabbed = gtk_grab_get_current();
+      //if (group && group->grabs) {
+      //   grabbed = GTK_WIDGET(group->grabs->data);
+      //}
       if (!grabbed) {
          grabbed = gtk_grab_get_current();
       }
diff --git a/vinagre/view/ovBox.c b/vinagre/view/ovBox.c
index 6f3e04e..ea9c730 100644
--- a/vinagre/view/ovBox.c
+++ b/vinagre/view/ovBox.c
@@ -119,8 +119,8 @@ ViewOvBoxInit(GTypeInstance *instance, // IN
    that = VIEW_OV_BOX(instance);
    that->priv = VIEW_OV_BOX_GET_PRIVATE(that);
    priv = that->priv;
-
-   GTK_WIDGET_UNSET_FLAGS(that, GTK_NO_WINDOW);
+   //HACK: correct??
+   gtk_widget_set_window(GTK_WIDGET(that), NULL);
 
    priv->underWin = NULL;
    priv->under = NULL;
@@ -152,7 +152,7 @@ ViewOvBoxInit(GTypeInstance *instance, // IN
 static void
 ViewOvBoxMap(GtkWidget *widget) // IN
 {
-   gdk_window_show(widget->window);
+   gdk_window_show(gtk_widget_get_window(widget));
    GTK_WIDGET_CLASS(parentClass)->map(widget);
 }
 
@@ -176,7 +176,7 @@ ViewOvBoxMap(GtkWidget *widget) // IN
 static void
 ViewOvBoxUnmap(GtkWidget *widget) // IN
 {
-   gdk_window_hide(widget->window);
+   gdk_window_hide(gtk_widget_get_window(widget));
    GTK_WIDGET_CLASS(parentClass)->unmap(widget);
 }
 
@@ -229,15 +229,15 @@ ViewOvBoxGetUnderGeometry(ViewOvBox *that, // IN
                           int *height)     // OUT
 {
    unsigned int min;
-   GtkAllocation *allocation;
+   GtkAllocation allocation;
 
    min = ViewOvBoxGetActualMin(that);
-   allocation = &GTK_WIDGET(that)->allocation;
+   gtk_widget_get_allocation(GTK_WIDGET(that), &allocation);
 
    *x = 0;
    *y = min;
-   *width = allocation->width;
-   *height = allocation->height - min;
+   *width = allocation.width;
+   *height = allocation.height - min;
 }
 
 
@@ -269,6 +269,7 @@ ViewOvBoxGetOverGeometry(ViewOvBox *that, // IN
    gboolean fill;
    guint padding;
    unsigned int boxWidth;
+   GtkAllocation allocation;
 
    priv = that->priv;
 
@@ -289,7 +290,9 @@ ViewOvBoxGetOverGeometry(ViewOvBox *that, // IN
       padding = 0;
    }
 
-   boxWidth = GTK_WIDGET(that)->allocation.width;
+   gtk_widget_get_allocation (GTK_WIDGET (that), &allocation);
+
+   boxWidth = allocation.width;
    if (!expand) {
       *width = MIN(priv->overR.width, boxWidth - padding);
       *x = padding;
@@ -327,11 +330,14 @@ static void
 ViewOvBoxSetBackground(ViewOvBox *that) // IN
 {
    GtkWidget *widget;
+   GtkStyle *style;
 
    widget = GTK_WIDGET(that);
-   gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
-   gtk_style_set_background(widget->style, that->priv->underWin, GTK_STATE_NORMAL);
-   gtk_style_set_background(widget->style, that->priv->overWin, GTK_STATE_NORMAL);
+   style = gtk_widget_get_style (widget);
+
+   gtk_style_set_background(style, gtk_widget_get_window(widget), GTK_STATE_NORMAL);
+   gtk_style_set_background(style, that->priv->underWin, GTK_STATE_NORMAL);
+   gtk_style_set_background(style, that->priv->overWin, GTK_STATE_NORMAL);
 }
 
 
@@ -358,9 +364,10 @@ ViewOvBoxRealize(GtkWidget *widget) // IN
    ViewOvBoxPrivate *priv;
    GdkWindowAttr attributes;
    gint mask;
-   GtkAllocation *allocation;
+   GtkAllocation allocation;
+   GtkWindow *window;
 
-   GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
+   gtk_widget_set_realized(widget, TRUE);
 
    that = VIEW_OV_BOX(widget);
    priv = that->priv;
@@ -372,15 +379,17 @@ ViewOvBoxRealize(GtkWidget *widget) // IN
    attributes.event_mask = gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK;
    mask = GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_X | GDK_WA_Y;
 
-   allocation = &widget->allocation;
-   attributes.x = allocation->x;
-   attributes.y = allocation->y;
-   attributes.width = allocation->width;
-   attributes.height = allocation->height;
-   widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
+   gtk_widget_get_allocation(widget, &allocation);
+   attributes.x = allocation.x;
+   attributes.y = allocation.y;
+   attributes.width = allocation.width;
+   attributes.height = allocation.height;
+   //HACK: fail!
+   window = gdk_window_new(gtk_widget_get_parent_window(widget),
 				   &attributes, mask);
-   gdk_window_set_user_data(widget->window, that);
-   widget->style = gtk_style_attach(widget->style, widget->window);
+   gtk_widget_set_window (widget, window);
+   gdk_window_set_user_data(window, that);
+   //widget->style = gtk_style_attach(widget->style, window);
 
    /*
     * The order in which we create the children X window matters: the child
@@ -389,7 +398,7 @@ ViewOvBoxRealize(GtkWidget *widget) // IN
 
    ViewOvBoxGetUnderGeometry(that, &attributes.x, &attributes.y,
                              &attributes.width, &attributes.height);
-   priv->underWin = gdk_window_new(widget->window, &attributes, mask);
+   priv->underWin = gdk_window_new(window, &attributes, mask);
    gdk_window_set_user_data(priv->underWin, that);
    if (priv->under) {
       gtk_widget_set_parent_window(priv->under, priv->underWin);
@@ -398,7 +407,7 @@ ViewOvBoxRealize(GtkWidget *widget) // IN
 
    ViewOvBoxGetOverGeometry(that, &attributes.x, &attributes.y,
                             &attributes.width, &attributes.height);
-   priv->overWin = gdk_window_new(widget->window, &attributes, mask);
+   priv->overWin = gdk_window_new(window, &attributes, mask);
    gdk_window_set_user_data(priv->overWin, that);
    if (priv->over) {
       gtk_widget_set_parent_window(priv->over, priv->overWin);
@@ -523,18 +532,20 @@ ViewOvBoxSizeAllocate(GtkWidget *widget,         // IN
    ViewOvBoxPrivate *priv;
    GtkAllocation under;
    GtkAllocation over;
+   GtkWindow *window;
 
-   widget->allocation = *allocation;
+   gtk_widget_set_allocation(widget, allocation);
 
    that = VIEW_OV_BOX(widget);
    priv = that->priv;
+   window = gtk_widget_get_window (widget);
 
    ViewOvBoxGetUnderGeometry(that, &under.x, &under.y, &under.width,
                              &under.height);
    ViewOvBoxGetOverGeometry(that, &over.x, &over.y, &over.width, &over.height);
 
-   if (GTK_WIDGET_REALIZED(widget)) {
-      gdk_window_move_resize(widget->window, allocation->x, allocation->y,
+   if (gtk_widget_get_realized(widget)) {
+      gdk_window_move_resize(window, allocation->x, allocation->y,
                              allocation->width, allocation->height);
       gdk_window_move_resize(priv->underWin, under.x, under.y, under.width,
                              under.height);
@@ -575,11 +586,12 @@ ViewOvBoxStyleSet(GtkWidget *widget,       // IN
 
    that = VIEW_OV_BOX(widget);
 
-   if (GTK_WIDGET_REALIZED(widget)) {
+   if (gtk_widget_get_realized(widget)) {
       ViewOvBoxSetBackground(that);
    }
-
-   GTK_WIDGET_CLASS(parentClass)->style_set(widget, previousStyle);
+   //HACK ??
+   gtk_widget_set_style(widget, previousStyle);
+   //GTK_WIDGET_CLASS(parentClass)->style_set(widget, previousStyle);
 }
 
 
@@ -679,7 +691,8 @@ ViewOvBoxClassInit(ViewOvBoxClass *klass) // IN
    widgetClass->unrealize = ViewOvBoxUnrealize;
    widgetClass->size_request = ViewOvBoxSizeRequest;
    widgetClass->size_allocate = ViewOvBoxSizeAllocate;
-   widgetClass->style_set = ViewOvBoxStyleSet;
+   //TODO
+   //widgetClass->style_set = ViewOvBoxStyleSet;
 
    klass->set_over = ViewOvBoxSetOver;
 
@@ -865,7 +878,7 @@ ViewOvBox_SetFraction(ViewOvBox *that, // IN
    g_return_if_fail(fraction >=0 && fraction <= 1);
 
    that->priv->fraction = fraction;
-   if (GTK_WIDGET_REALIZED(that)) {
+   if (gtk_widget_get_realized(that)) {
       int x;
       int y;
       int width;
diff --git a/vinagre/vinagre-app.c b/vinagre/vinagre-app.c
index b54969d..134c76d 100644
--- a/vinagre/vinagre-app.c
+++ b/vinagre/vinagre-app.c
@@ -220,7 +220,7 @@ vinagre_app_get_active_window (VinagreApp *app)
    * first one shows its window.
    */
 
-  if (!GTK_WIDGET_REALIZED (GTK_WIDGET (app->priv->active_window)))
+  if (!gtk_widget_get_realized (GTK_WIDGET (app->priv->active_window)))
     gtk_widget_realize (GTK_WIDGET (app->priv->active_window));
 
   return app->priv->active_window;
@@ -235,6 +235,7 @@ is_in_viewport (VinagreWindow *window,
 {
   GdkScreen *s;
   GdkDisplay *display;
+  GdkWindow *gwindow;
   const gchar *cur_name;
   const gchar *name;
   gint cur_n;
@@ -263,8 +264,9 @@ is_in_viewport (VinagreWindow *window,
     return FALSE;
 
   /* Check for viewport match */
-  gdk_window_get_position (GTK_WIDGET (window)->window, &x, &y);
-  gdk_drawable_get_size (GTK_WIDGET (window)->window, &width, &height);
+  gwindow = gtk_widget_get_window (GTK_WIDGET (window));
+  gdk_window_get_position (gwindow, &x, &y);
+  gdk_drawable_get_size (gwindow, &width, &height);
   vinagre_utils_get_current_viewport (screen, &vp_x, &vp_y);
   x += vp_x;
   y += vp_y;
diff --git a/vinagre/vinagre-applet.c b/vinagre/vinagre-applet.c
index be32a42..9404d71 100644
--- a/vinagre/vinagre-applet.c
+++ b/vinagre/vinagre-applet.c
@@ -99,34 +99,37 @@ vinagre_applet_get_icon (VinagreApplet *applet)
 static void
 vinagre_applet_check_size (VinagreApplet *applet)
 {
+  GtkAllocation allocation;
+
+  gtk_widget_get_allocation (GTK_WIDGET (applet), &allocation);
   /* we don't use the size function here, but the yet allocated size because the
      size value is false (kind of rounded) */
   if (PANEL_APPLET_VERTICAL(panel_applet_get_orient (PANEL_APPLET (applet))))
     {
-      if (applet->size != GTK_WIDGET(applet)->allocation.width)
+      if (applet->size != allocation.width)
 	{
-	  applet->size = GTK_WIDGET(applet)->allocation.width;
+	  applet->size = allocation.width;
 	  vinagre_applet_get_icon (applet);
 	  gtk_widget_set_size_request (GTK_WIDGET(applet), applet->size, applet->icon_height + 2);
 	}
 
       /* Adjusting in case the icon size has changed */
-      if (GTK_WIDGET(applet)->allocation.height < applet->icon_height + 2)
+      if (allocation.height < applet->icon_height + 2)
 	{
 	  gtk_widget_set_size_request (GTK_WIDGET(applet), applet->size, applet->icon_height + 2);
 	}
     }
   else
     {
-      if (applet->size != GTK_WIDGET(applet)->allocation.height)
+      if (applet->size != allocation.height)
 	{
-	  applet->size = GTK_WIDGET(applet)->allocation.height;
+	  applet->size = allocation.height;
 	  vinagre_applet_get_icon (applet);
 	  gtk_widget_set_size_request (GTK_WIDGET(applet), applet->icon_width + 2, applet->size);
 	}
 
       /* Adjusting in case the icon size has changed */
-      if (GTK_WIDGET(applet)->allocation.width < applet->icon_width + 2)
+      if (allocation.width < applet->icon_width + 2)
 	{
 	  gtk_widget_set_size_request (GTK_WIDGET(applet), applet->icon_width + 2, applet->size);
 	}
@@ -140,12 +143,18 @@ vinagre_applet_draw_cb (VinagreApplet *applet)
   GdkColor color;
   GdkGC *gc;
   GdkPixmap *background;
+  GdkWindow *window;
+  GtkAllocation allocation;
+
+  window = gtk_widget_get_window (GTK_WIDGET (applet));
 
-  if (GTK_WIDGET (applet)->window == NULL)
+  if (window == NULL)
     return FALSE;
 
+  gtk_widget_get_allocation (GTK_WIDGET (applet), &allocation);
+
   /* Clear the window so we can draw on it later */
-  gdk_window_clear (GTK_WIDGET(applet)->window);
+  gdk_window_clear (window);
 
   /* retrieve applet size */
   vinagre_applet_get_icon (applet);
@@ -157,17 +166,17 @@ vinagre_applet_draw_cb (VinagreApplet *applet)
   if (applet->icon == NULL)
     return FALSE;
 
-  w = GTK_WIDGET(applet)->allocation.width;
-  h = GTK_WIDGET(applet)->allocation.height;
+  w = allocation.width;
+  h = allocation.height;
 
-  gc = gdk_gc_new (GTK_WIDGET(applet)->window);
+  gc = gdk_gc_new (window);
 
   /* draw pixmap background */
   bg_type = panel_applet_get_background (PANEL_APPLET (applet), &color, &background);
   if (bg_type == PANEL_PIXMAP_BACKGROUND)
     {
       /* fill with given background pixmap */
-      gdk_draw_drawable (GTK_WIDGET(applet)->window, gc, background, 0, 0, 0, 0, w, h);
+      gdk_draw_drawable (window, gc, background, 0, 0, 0, 0, w, h);
     }
 	
   /* draw color background */
@@ -175,11 +184,11 @@ vinagre_applet_draw_cb (VinagreApplet *applet)
     {
       gdk_gc_set_rgb_fg_color (gc,&color);
       gdk_gc_set_fill (gc,GDK_SOLID);
-      gdk_draw_rectangle (GTK_WIDGET(applet)->window, gc, TRUE, 0, 0, w, h);
+      gdk_draw_rectangle (window, gc, TRUE, 0, 0, w, h);
     }
 
   /* draw icon at center */
-  gdk_draw_pixbuf (GTK_WIDGET(applet)->window, gc, applet->icon,
+  gdk_draw_pixbuf (window, gc, applet->icon,
 		   0, 0, (w - applet->icon_width)/2, (h - applet->icon_height)/2,
 		   applet->icon_width, applet->icon_height,
 		   GDK_RGB_DITHER_NONE, 0, 0);
@@ -219,9 +228,12 @@ menu_position (GtkMenu    *menu,
 {
   int applet_height, applet_width;
   GtkRequisition requisition;
+  GdkWindow *window;
+
+  window = gtk_widget_get_window (applet);
 
-  gdk_window_get_origin (applet->window, x, y);
-  gdk_drawable_get_size (applet->window, &applet_width, &applet_height);
+  gdk_window_get_origin (window, x, y);
+  gdk_drawable_get_size (window, &applet_width, &applet_height);
   gtk_widget_size_request (GTK_WIDGET (menu), &requisition);
 
   switch (panel_applet_get_orient (PANEL_APPLET (applet)))
diff --git a/vinagre/vinagre-bacon.c b/vinagre/vinagre-bacon.c
index 768befd..992872a 100644
--- a/vinagre/vinagre-bacon.c
+++ b/vinagre/vinagre-bacon.c
@@ -70,6 +70,7 @@ vinagre_bacon_message_received (const char *message,
   VinagreApp *app;
   VinagreWindow *window;
   GdkDisplay *display;
+  GdkWindow *gwindow;
   GdkScreen *screen;
   gboolean new_window = FALSE;
   GSList *servers = NULL;
@@ -166,13 +167,14 @@ vinagre_bacon_message_received (const char *message,
    * terminal. We also need to make sure that the window
    * has been realized otherwise it will not work. lame.
    */
-  if (!GTK_WIDGET_REALIZED (window))
+  if (!gtk_widget_get_realized (window))
     gtk_widget_realize (GTK_WIDGET (window));
 
+  gwindow = gtk_widget_get_window (GTK_WIDGET (window));
   if (startup_timestamp <= 0)
-    startup_timestamp = gdk_x11_get_server_time (GTK_WIDGET (window)->window);
+    startup_timestamp = gdk_x11_get_server_time (gwindow);
 
-  gdk_x11_window_set_user_time (GTK_WIDGET (window)->window,
+  gdk_x11_window_set_user_time (gwindow,
 				startup_timestamp);
   gtk_window_present (GTK_WINDOW (window));
 
diff --git a/vinagre/vinagre-commands.c b/vinagre/vinagre-commands.c
index 5f38981..af7dbee 100644
--- a/vinagre/vinagre-commands.c
+++ b/vinagre/vinagre-commands.c
@@ -250,7 +250,7 @@ vinagre_cmd_view_show_toolbar	(GtkAction     *action,
 
   vinagre_cache_prefs_set_boolean ("window",
 				   "toolbar-visible",
-				   GTK_WIDGET_VISIBLE (window->priv->toolbar));
+				   gtk_widget_get_visible (GTK_WIDGET (window->priv->toolbar)));
 }
 
 void
@@ -263,7 +263,7 @@ vinagre_cmd_view_show_statusbar	(GtkAction     *action,
 
   vinagre_cache_prefs_set_boolean ("window",
 				   "statusbar-visible",
-				   GTK_WIDGET_VISIBLE (window->priv->statusbar));
+				   gtk_widget_get_visible (GTK_WIDGET (window->priv->statusbar)));
 }
 
 void
@@ -276,7 +276,7 @@ vinagre_cmd_view_show_fav_panel	(GtkAction     *action,
 
   vinagre_cache_prefs_set_boolean ("window",
 				   "side-panel-visible",
-				   GTK_WIDGET_VISIBLE (window->priv->fav_panel));
+				   gtk_widget_get_visible (GTK_WIDGET (window->priv->fav_panel)));
 }
 
 void
diff --git a/vinagre/vinagre-fav.c b/vinagre/vinagre-fav.c
index 0843ac0..df4f706 100644
--- a/vinagre/vinagre-fav.c
+++ b/vinagre/vinagre-fav.c
@@ -221,6 +221,8 @@ menu_position (GtkMenu    *menu,
   gint wx, wy;
   GtkRequisition requisition;
   GtkWidget *w;
+  GdkWindow *window;
+  GtkAllocation allocation;
 
   w = fav->priv->tree;
   path = get_current_path (fav);
@@ -232,18 +234,20 @@ menu_position (GtkMenu    *menu,
 
   wx = rect.x;
   wy = rect.y;
+  window = gtk_widget_get_window (w);
 
-  gdk_window_get_origin (w->window, x, y);
+  gdk_window_get_origin (window, x, y);
 	
   gtk_widget_size_request (GTK_WIDGET (menu), &requisition);
+  gtk_widget_get_allocation (w, &allocation);
 
   if (gtk_widget_get_direction (w) == GTK_TEXT_DIR_RTL)
-    *x += w->allocation.x + w->allocation.width - requisition.width - 10;
+    *x += allocation.x + allocation.width - requisition.width - 10;
   else
-    *x += w->allocation.x + 10 ;
+    *x += allocation.x + 10 ;
 
   wy = MAX (*y + 5, *y + wy + 5);
-  wy = MIN (wy, *y + w->allocation.height - requisition.height - 5);
+  wy = MIN (wy, *y + allocation.height - requisition.height - 5);
 	
   *y = wy;
 
@@ -726,12 +730,12 @@ drag_data_received_handl (GtkWidget *widget,
   gchar *_sdata;
   gboolean success = FALSE;
 
-  if ((selection_data != NULL) && (selection_data->length >= 0))
+  if ((selection_data != NULL) && (gtk_selection_data_get_length (selection_data) >= 0))
     {
       switch (target_type)
 	{
 	  case TARGET_VINAGRE:
-	    _sdata = (gchar*)selection_data-> data;
+	    _sdata = (gchar*)gtk_selection_data_get_data (selection_data);
 	    success = TRUE;
 	   break;
 
diff --git a/vinagre/vinagre-notebook.c b/vinagre/vinagre-notebook.c
index d8f5f61..83ed0b4 100644
--- a/vinagre/vinagre-notebook.c
+++ b/vinagre/vinagre-notebook.c
@@ -180,7 +180,7 @@ drag_data_get_handl (GtkWidget *widget,
 
 	/*FIXME: Set other properties of the connection*/
 	gtk_selection_data_set (selection_data,
-				selection_data->target,
+				gtk_selection_data_get_target (selection_data),
 				8,
 				(guchar*) data,
 				strlen (data));
diff --git a/vinagre/vinagre-plugins-engine.c b/vinagre/vinagre-plugins-engine.c
index e441b58..fb63183 100644
--- a/vinagre/vinagre-plugins-engine.c
+++ b/vinagre/vinagre-plugins-engine.c
@@ -861,7 +861,7 @@ vinagre_plugins_engine_configure_plugin (VinagrePluginsEngine *engine,
 	gtk_window_set_transient_for (GTK_WINDOW (conf_dlg),
 				      parent);
 
-	wg = parent->group;		      
+	wg = gtk_window_get_group (parent);		      
 	if (wg == NULL)
 	{
 		wg = gtk_window_group_new ();
diff --git a/vinagre/vinagre-spinner.c b/vinagre/vinagre-spinner.c
index 1cb8009..5485951 100644
--- a/vinagre/vinagre-spinner.c
+++ b/vinagre/vinagre-spinner.c
@@ -610,7 +610,7 @@ vinagre_spinner_init (VinagreSpinner *spinner)
 
 	priv = spinner->priv = VINAGRE_SPINNER_GET_PRIVATE (spinner);
 
-	GTK_WIDGET_SET_FLAGS (GTK_WIDGET (spinner), GTK_NO_WINDOW);
+	gtk_widget_set_window (GTK_WIDGET (spinner), NULL);
 
 	priv->cache = vinagre_spinner_cache_ref ();
 	priv->size = GTK_ICON_SIZE_DIALOG;
@@ -630,8 +630,10 @@ vinagre_spinner_expose (GtkWidget      *widget,
 	GdkGC *gc;
 	int x_offset, y_offset, width, height;
 	GdkRectangle pix_area, dest;
+    GtkAllocation allocation;
+    GdkWindow *window;
 
-	if (!GTK_WIDGET_DRAWABLE (spinner))
+	if (!gtk_widget_is_drawable (widget))
 	{
 		return FALSE;
 	}
@@ -662,11 +664,12 @@ vinagre_spinner_expose (GtkWidget      *widget,
 	height = gdk_pixbuf_get_height (pixbuf);
 
 	/* Compute the offsets for the image centered on our allocation */
-	x_offset = (widget->allocation.width - width) / 2;
-	y_offset = (widget->allocation.height - height) / 2;
+    gtk_widget_get_allocation (widget, &allocation);
+	x_offset = (allocation.width - width) / 2;
+	y_offset = (allocation.height - height) / 2;
 
-	pix_area.x = x_offset + widget->allocation.x;
-	pix_area.y = y_offset + widget->allocation.y;
+	pix_area.x = x_offset + allocation.x;
+	pix_area.y = y_offset + allocation.y;
 	pix_area.width = width;
 	pix_area.height = height;
 
@@ -675,10 +678,12 @@ vinagre_spinner_expose (GtkWidget      *widget,
 		return FALSE;
 	}
 
-	gc = gdk_gc_new (widget->window);
-	gdk_draw_pixbuf (widget->window, gc, pixbuf,
-			 dest.x - x_offset - widget->allocation.x,
-			 dest.y - y_offset - widget->allocation.y,
+    window = gtk_widget_get_window (widget);
+
+	gc = gdk_gc_new (window);
+	gdk_draw_pixbuf (window, gc, pixbuf,
+			 dest.x - x_offset - allocation.x,
+			 dest.y - y_offset - allocation.y,
 			 dest.x, dest.y,
 			 dest.width, dest.height,
 			 GDK_RGB_DITHER_MAX, 0, 0);
@@ -725,7 +730,7 @@ vinagre_spinner_start (VinagreSpinner *spinner)
 
 	priv->spinning = TRUE;
 
-	if (GTK_WIDGET_MAPPED (GTK_WIDGET (spinner)) &&
+	if (gtk_widget_get_mapped (GTK_WIDGET (spinner)) &&
 			       priv->timer_task == 0 &&
 			       vinagre_spinner_load_images (spinner))
 	{
@@ -770,7 +775,7 @@ vinagre_spinner_stop (VinagreSpinner *spinner)
 	{
 		vinagre_spinner_remove_update_callback (spinner);
 
-		if (GTK_WIDGET_MAPPED (GTK_WIDGET (spinner)))
+		if (gtk_widget_get_mapped (GTK_WIDGET (spinner)))
 			gtk_widget_queue_draw (GTK_WIDGET (spinner));
 	}
 }
diff --git a/vinagre/vinagre-tab.c b/vinagre/vinagre-tab.c
index bab5c19..33690c6 100644
--- a/vinagre/vinagre-tab.c
+++ b/vinagre/vinagre-tab.c
@@ -270,10 +270,10 @@ active_connections_button_clicked  (GtkToolButton *button,
       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 
       label = vinagre_connection_get_best_name (conn);
-      if ((l->data == tab) && (GTK_IS_LABEL (GTK_BIN (item)->child)))
+      if ((l->data == tab) && (GTK_IS_LABEL (gtk_bin_get_child (GTK_BIN (item)))))
 	{
 	  str = g_strdup_printf ("<b>%s</b>", label);
-	  gtk_label_set_use_markup (GTK_LABEL (GTK_BIN (item)->child), TRUE);
+	  gtk_label_set_use_markup (GTK_LABEL (gtk_bin_get_child (GTK_BIN (item))), TRUE);
 	  g_free (label);
 	  label = str;
 	}
@@ -316,7 +316,8 @@ setup_layout (VinagreTab *tab)
 
   tab->priv->toolbar = gtk_toolbar_new ();
   gtk_toolbar_set_show_arrow (GTK_TOOLBAR (tab->priv->toolbar), FALSE);
-  GTK_WIDGET_SET_FLAGS (tab->priv->toolbar, GTK_NO_SHOW_ALL);
+  //HACK: correct??
+  gtk_widget_hide_all (tab->priv->toolbar);
 
   gtk_toolbar_set_style (GTK_TOOLBAR (tab->priv->toolbar), GTK_TOOLBAR_BOTH_HORIZ);
 
diff --git a/vinagre/vinagre-utils.c b/vinagre/vinagre-utils.c
index 0b00045..462ea22 100644
--- a/vinagre/vinagre-utils.c
+++ b/vinagre/vinagre-utils.c
@@ -112,7 +112,7 @@ vinagre_utils_show_many_errors (const gchar *title, GSList *items, GtkWindow *pa
 void
 vinagre_utils_toggle_widget_visible (GtkWidget *widget)
 {
-  if (GTK_WIDGET_VISIBLE (widget))
+  if (gtk_widget_get_visible (widget))
     gtk_widget_hide (widget);
   else
     gtk_widget_show_all (widget);
@@ -328,9 +328,9 @@ vinagre_utils_get_window_workspace (GtkWindow *gtkwindow)
 	guint ret = VINAGRE_ALL_WORKSPACES;
 
 	g_return_val_if_fail (GTK_IS_WINDOW (gtkwindow), 0);
-	g_return_val_if_fail (GTK_WIDGET_REALIZED (GTK_WIDGET (gtkwindow)), 0);
+	g_return_val_if_fail (gtk_widget_get_realized (GTK_WIDGET (gtkwindow)), 0);
 
-	window = GTK_WIDGET (gtkwindow)->window;
+	window = gtk_widget_get_window (GTK_WIDGET (gtkwindow));
 	display = gdk_drawable_get_display (window);
 
 	gdk_error_trap_push ();
@@ -616,10 +616,10 @@ control_ok_button (GtkEditable *entry, ControlOKButton *data)
 {
   gboolean enabled = TRUE;
 
-  if (GTK_WIDGET_VISIBLE (data->uname))
+  if (gtk_widget_get_visible (data->uname))
     enabled = enabled && gtk_entry_get_text_length (GTK_ENTRY (data->uname)) > 0;
 
-  if (GTK_WIDGET_VISIBLE (data->pw))
+  if (gtk_widget_get_visible (data->pw))
     enabled = enabled && gtk_entry_get_text_length (GTK_ENTRY (data->pw)) > 0;
 
   gtk_widget_set_sensitive (data->button, enabled);
diff --git a/vinagre/vinagre-window.c b/vinagre/vinagre-window.c
index fc0bc3c..61eb2f4 100644
--- a/vinagre/vinagre-window.c
+++ b/vinagre/vinagre-window.c
@@ -102,15 +102,15 @@ vinagre_window_show_hide_controls (VinagreWindow *window)
 {
   if (window->priv->fullscreen)
     {
-      window->priv->fav_panel_visible = GTK_WIDGET_VISIBLE (window->priv->fav_panel);
+      window->priv->fav_panel_visible = gtk_widget_get_visible (window->priv->fav_panel);
       gtk_widget_hide (window->priv->fav_panel);
 
-      window->priv->toolbar_visible = GTK_WIDGET_VISIBLE (window->priv->toolbar);
+      window->priv->toolbar_visible = gtk_widget_get_visible (window->priv->toolbar);
       gtk_widget_hide (window->priv->toolbar);
 
       gtk_widget_hide (window->priv->menubar);
 
-      window->priv->statusbar_visible = GTK_WIDGET_VISIBLE (window->priv->statusbar);
+      window->priv->statusbar_visible = gtk_widget_get_visible (window->priv->statusbar);
       gtk_widget_hide (window->priv->statusbar);
 
       gtk_notebook_set_show_tabs (GTK_NOTEBOOK (window->priv->notebook), FALSE);
