diff --git a/src/empathy-call-window-fullscreen.c b/src/empathy-call-window-fullscreen.c
index e1c3d7a..a9c67f8 100644
--- a/src/empathy-call-window-fullscreen.c
+++ b/src/empathy-call-window-fullscreen.c
@@ -45,7 +45,7 @@ struct _EmpathyCallWindowFullscreenPriv
   EmpathyCallWindow *parent_window;
 
   GtkWidget *leave_fullscreen_popup;
-  GtkWidget *video_widget;
+  GtkWidget *output_section;
 
   guint popup_timeout;
   gboolean popup_creation_in_progress;
@@ -64,18 +64,20 @@ static gboolean empathy_call_window_fullscreen_hide_popup (
 
 static void
 empathy_call_window_fullscreen_set_cursor_visible (
-    EmpathyCallWindowFullscreen *fs,
-    gboolean show_cursor)
+    EmpathyCallWindowFullscreen *fs, gboolean show_cursor)
 {
   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (fs);
 
-  if (priv->video_widget != NULL && !show_cursor)
+  if (priv->output_section != NULL)
     {
-      gdk_window_set_cursor (gtk_widget_get_window (priv->video_widget),
-          gdk_cursor_new (GDK_BLANK_CURSOR));
+      GdkCursor *cursor = NULL;
+
+      if (!show_cursor)
+        cursor = gdk_cursor_new (GDK_BLANK_CURSOR);
+
+      gdk_window_set_cursor (gtk_widget_get_window (priv->output_section),
+          cursor);
     }
-  else
-    gdk_window_set_cursor (gtk_widget_get_window (priv->video_widget), NULL);
 }
 
 static void
@@ -145,7 +147,6 @@ empathy_call_window_fullscreen_show_popup (EmpathyCallWindowFullscreen *self)
       gtk_window_move (GTK_WINDOW (priv->leave_fullscreen_popup),
           fullscreen_rect.width + fullscreen_rect.x - leave_fullscreen_width,
           fullscreen_rect.y);
-
     }
   else
     {
@@ -164,7 +165,7 @@ empathy_call_window_fullscreen_hide_popup (EmpathyCallWindowFullscreen *fs)
 {
   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (fs);
 
-  if (priv->video_widget == NULL || !fs->is_fullscreen)
+  if (priv->output_section == NULL || !fs->is_fullscreen)
     return TRUE;
 
   gtk_widget_hide (priv->leave_fullscreen_popup);
@@ -188,7 +189,8 @@ empathy_call_window_fullscreen_init (EmpathyCallWindowFullscreen *self)
     "leave_fullscreen_button", &self->leave_fullscreen_button,
     NULL);
 
-  gtk_widget_add_events (priv->leave_fullscreen_popup, GDK_POINTER_MOTION_MASK);
+  gtk_widget_add_events (
+      priv->leave_fullscreen_popup, GDK_POINTER_MOTION_MASK);
 
   g_object_unref (gui);
   g_free (filename);
@@ -285,10 +287,9 @@ empathy_call_window_fullscreen_set_fullscreen (EmpathyCallWindowFullscreen *fs,
 }
 
 void
-empathy_call_window_fullscreen_set_video_widget (
-    EmpathyCallWindowFullscreen *fs,
-    GtkWidget *video_widget)
+empathy_call_window_fullscreen_set_output_section (
+    EmpathyCallWindowFullscreen *fs, GtkWidget *output_section)
 {
   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (fs);
-  priv->video_widget = video_widget;
+  priv->output_section = output_section;
 }
diff --git a/src/empathy-call-window-fullscreen.h b/src/empathy-call-window-fullscreen.h
index 8bde16c..a167612 100644
--- a/src/empathy-call-window-fullscreen.h
+++ b/src/empathy-call-window-fullscreen.h
@@ -66,9 +66,8 @@ EmpathyCallWindowFullscreen *empathy_call_window_fullscreen_new (
 void empathy_call_window_fullscreen_set_fullscreen (
     EmpathyCallWindowFullscreen *fs,
     gboolean set_fullscreen);
-void empathy_call_window_fullscreen_set_video_widget (
-    EmpathyCallWindowFullscreen *fs,
-    GtkWidget *video_widget);
+void empathy_call_window_fullscreen_set_output_section (
+    EmpathyCallWindowFullscreen *fs, GtkWidget *output_section);
 void empathy_call_window_fullscreen_show_popup (
     EmpathyCallWindowFullscreen *fs);
 
diff --git a/src/empathy-call-window.c b/src/empathy-call-window.c
index 520a928..438c78a 100644
--- a/src/empathy-call-window.c
+++ b/src/empathy-call-window.c
@@ -52,13 +52,24 @@
 #define CONTENT_HBOX_SPACING 3
 #define CONTENT_HBOX_CHILDREN_PACKING_PADDING 3
 
+/* The video_preview is overlaid over the remote video, at its bottom right.
+   We want a 5 pixels padding between the right edge of the video_preview and
+   the edge of the video_output section */
+#define VIDEO_PREVIEW_BORDER 5
+
 #define SELF_VIDEO_SECTION_WIDTH 160
 #define SELF_VIDEO_SECTION_HEIGTH 120
 
+/* Since the video_preview is overlaid over the video_output section, the
+   video_output needs to be bigger than the default size in order not to be
+   mostly covered by the video_preview */
+#define OUTPUT_FRAME_INITIAL_WIDTH EMPATHY_VIDEO_WIDGET_DEFAULT_WIDTH * 1.5
+#define OUTPUT_FRAME_INITIAL_HEIGHT EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT * 1.5
+
 /* The avatar's default width and height are set to the same value because we
    want a square icon. */
-#define REMOTE_CONTACT_AVATAR_DEFAULT_WIDTH EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT
-#define REMOTE_CONTACT_AVATAR_DEFAULT_HEIGHT EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT
+#define REMOTE_CONTACT_AVATAR_DEFAULT_WIDTH OUTPUT_FRAME_INITIAL_HEIGHT
+#define REMOTE_CONTACT_AVATAR_DEFAULT_HEIGHT OUTPUT_FRAME_INITIAL_HEIGHT
 
 /* If an video input error occurs, the error message will start with "v4l" */
 #define VIDEO_INPUT_ERROR_PREFIX "v4l"
@@ -122,10 +133,15 @@ struct _EmpathyCallWindowPriv
 
   /* The frames and boxes that contain self and remote avatar and video
      input/output. When we redial, we destroy and re-create the boxes */
-  GtkWidget *remote_user_output_frame;
+  GtkWidget *output_frame;
   GtkWidget *self_user_output_frame;
   GtkWidget *remote_user_output_hbox;
   GtkWidget *self_user_output_hbox;
+  GtkWidget *output_fixed;
+
+  /* The GtkEventBox containing the output_fixed. It is used so to catch
+     mouse events occuring over every widgets contained in the fixed. */
+  GtkWidget *output_event_box;
 
   /* We keep a reference on the hbox which contains the main content so we can
      easilly repack everything when toggling fullscreen */
@@ -136,7 +152,7 @@ struct _EmpathyCallWindowPriv
      it needs to be repacked. We keep a reference on it for easier access. */
   GtkWidget *vbox;
 
-  gulong video_output_motion_handler_id;
+  gulong output_event_box_motion_handler_id;
 
   gdouble volume;
   GtkWidget *volume_progress_bar;
@@ -180,63 +196,62 @@ struct _EmpathyCallWindowPriv
   (G_TYPE_INSTANCE_GET_PRIVATE ((o), EMPATHY_TYPE_CALL_WINDOW, \
     EmpathyCallWindowPriv))
 
-static void empathy_call_window_realized_cb (GtkWidget *widget,
+static gboolean empathy_call_window_bus_message (GstBus *bus,
+  GstMessage *message, gpointer user_data);
+
+static void empathy_call_window_camera_toggled_cb (GtkToggleToolButton *toggle,
   EmpathyCallWindow *window);
 
+static gboolean empathy_call_window_configure_cb (GtkWidget *widget,
+  GdkEventConfigure *event, EmpathyCallWindow *window);
+
 static gboolean empathy_call_window_delete_cb (GtkWidget *widget,
   GdkEvent *event, EmpathyCallWindow *window);
 
-static gboolean empathy_call_window_state_event_cb (GtkWidget *widget,
-  GdkEventWindowState *event, EmpathyCallWindow *window);
-
-static void empathy_call_window_sidebar_toggled_cb (GtkToggleButton *toggle,
-  EmpathyCallWindow *window);
-
-static void empathy_call_window_camera_toggled_cb (GtkToggleToolButton *toggle,
+static void empathy_call_window_fullscreen_cb (gpointer object,
   EmpathyCallWindow *window);
 
-static void empathy_call_window_set_send_video (EmpathyCallWindow *window,
-  gboolean send);
+static void empathy_call_window_fullscreen_toggle (EmpathyCallWindow *window);
 
-static void empathy_call_window_send_video_toggled_cb (GtkToggleAction *toggle,
+static void empathy_call_window_hangup_cb (gpointer object,
   EmpathyCallWindow *window);
 
-static void empathy_call_window_show_preview_toggled_cb (GtkToggleAction *toggle,
-  EmpathyCallWindow *window);
+static gboolean empathy_call_window_key_press_cb (GtkWidget *video_output,
+  GdkEventKey *event, EmpathyCallWindow *window);
 
 static void empathy_call_window_mic_toggled_cb (
   GtkToggleToolButton *toggle, EmpathyCallWindow *window);
 
-static void empathy_call_window_sidebar_hidden_cb (EmpathySidebar *sidebar,
-  EmpathyCallWindow *window);
+static gboolean empathy_call_window_place_output_widgets (gpointer user_data);
 
-static void empathy_call_window_sidebar_shown_cb (EmpathySidebar *sidebar,
+static void empathy_call_window_realized_cb (GtkWidget *widget,
   EmpathyCallWindow *window);
 
-static void empathy_call_window_hangup_cb (gpointer object,
+static void empathy_call_window_redial_cb (gpointer object,
   EmpathyCallWindow *window);
 
-static void empathy_call_window_fullscreen_cb (gpointer object,
-  EmpathyCallWindow *window);
+static void empathy_call_window_restart_call (EmpathyCallWindow *window);
 
-static void empathy_call_window_fullscreen_toggle (EmpathyCallWindow *window);
+static void empathy_call_window_send_video_toggled_cb (GtkToggleAction *toggle,
+  EmpathyCallWindow *window);
 
-static gboolean empathy_call_window_video_button_press_cb (GtkWidget *video_output,
-  GdkEventButton *event, EmpathyCallWindow *window);
+static void empathy_call_window_set_send_video (EmpathyCallWindow *window,
+  gboolean send);
 
-static gboolean empathy_call_window_key_press_cb (GtkWidget *video_output,
-  GdkEventKey *event, EmpathyCallWindow *window);
+static void empathy_call_window_show_preview_toggled_cb (GtkToggleAction *toggle,
+  EmpathyCallWindow *window);
 
-static gboolean empathy_call_window_video_output_motion_notify (GtkWidget *widget,
-  GdkEventMotion *event, EmpathyCallWindow *window);
+static void empathy_call_window_sidebar_hidden_cb (EmpathySidebar *sidebar,
+  EmpathyCallWindow *window);
 
-static void empathy_call_window_video_menu_popup (EmpathyCallWindow *window,
-  guint button);
+static void empathy_call_window_sidebar_shown_cb (EmpathySidebar *sidebar,
+  EmpathyCallWindow *window);
 
-static void empathy_call_window_redial_cb (gpointer object,
+static void empathy_call_window_sidebar_toggled_cb (GtkToggleButton *toggle,
   EmpathyCallWindow *window);
 
-static void empathy_call_window_restart_call (EmpathyCallWindow *window);
+static gboolean empathy_call_window_state_event_cb (GtkWidget *widget,
+  GdkEventWindowState *event, EmpathyCallWindow *window);
 
 static void empathy_call_window_status_message (EmpathyCallWindow *window,
   gchar *message);
@@ -244,11 +259,16 @@ static void empathy_call_window_status_message (EmpathyCallWindow *window,
 static void empathy_call_window_update_avatars_visibility (EmpathyTpCall *call,
   EmpathyCallWindow *window);
 
-static gboolean empathy_call_window_bus_message (GstBus *bus,
-  GstMessage *message, gpointer user_data);
+static gboolean empathy_call_window_video_button_press_cb (GtkWidget *video_output,
+  GdkEventButton *event, EmpathyCallWindow *window);
 
-static void
-empathy_call_window_volume_changed_cb (GtkScaleButton *button,
+static void empathy_call_window_video_menu_popup (EmpathyCallWindow *window,
+  guint button);
+
+static gboolean empathy_call_window_output_motion_notify (GtkWidget *widget,
+  GdkEventMotion *event, EmpathyCallWindow *window);
+
+static void empathy_call_window_volume_changed_cb (GtkScaleButton *button,
   gdouble value, EmpathyCallWindow *window);
 
 static void
@@ -566,17 +586,15 @@ empathy_call_window_setup_remote_frame (GstBus *bus, EmpathyCallWindow *self)
   gtk_box_pack_start (GTK_BOX (priv->remote_user_output_hbox),
       priv->remote_user_avatar_widget, TRUE, TRUE, 0);
 
-  priv->video_output = empathy_video_widget_new (bus);
+  priv->video_output = empathy_video_widget_new_with_size (bus,
+      OUTPUT_FRAME_INITIAL_WIDTH, OUTPUT_FRAME_INITIAL_HEIGHT);
   gtk_box_pack_start (GTK_BOX (priv->remote_user_output_hbox),
       priv->video_output, TRUE, TRUE, 0);
 
-  gtk_widget_add_events (priv->video_output,
-      GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
-  g_signal_connect (G_OBJECT (priv->video_output), "button-press-event",
-      G_CALLBACK (empathy_call_window_video_button_press_cb), self);
+  gtk_widget_add_events (priv->video_output, GDK_POINTER_MOTION_MASK);
 
-  gtk_container_add (GTK_CONTAINER (priv->remote_user_output_frame),
-      priv->remote_user_output_hbox);
+  gtk_fixed_put (GTK_FIXED (priv->output_fixed),
+    priv->remote_user_output_hbox, 0, 0);
 
   priv->audio_output = empathy_audio_sink_new ();
   gst_object_ref (priv->audio_output);
@@ -640,6 +658,8 @@ empathy_call_window_setup_video_preview (EmpathyCallWindow *window)
   gtk_box_pack_start (GTK_BOX (priv->self_user_output_hbox),
       priv->video_preview, TRUE, TRUE, 0);
 
+  gtk_widget_add_events (priv->video_preview, GDK_POINTER_MOTION_MASK);
+
   preview = empathy_video_widget_get_element (
       EMPATHY_VIDEO_WIDGET (priv->video_preview));
   gst_bin_add_many (GST_BIN (priv->pipeline), priv->video_input,
@@ -722,11 +742,24 @@ empathy_call_window_init (EmpathyCallWindow *self)
   bus = gst_pipeline_get_bus (GST_PIPELINE (priv->pipeline));
   gst_bus_add_watch (bus, empathy_call_window_bus_message, self);
 
-  priv->remote_user_output_frame = gtk_frame_new (NULL);
-  gtk_widget_set_size_request (priv->remote_user_output_frame,
-      EMPATHY_VIDEO_WIDGET_DEFAULT_WIDTH, EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT);
+  priv->output_fixed = gtk_fixed_new ();
+  priv->output_event_box = gtk_event_box_new ();
+  gtk_event_box_set_above_child (GTK_EVENT_BOX (priv->output_event_box), TRUE);
+  gtk_widget_add_events (priv->output_event_box,
+      GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
+  g_signal_connect (G_OBJECT (priv->output_event_box), "button-press-event",
+      G_CALLBACK (empathy_call_window_video_button_press_cb), self);
+  gtk_container_add (GTK_CONTAINER (priv->output_event_box),
+      priv->output_fixed);
+
+  priv->output_frame = gtk_frame_new (NULL);
+  gtk_container_add (GTK_CONTAINER (priv->output_frame),
+      priv->output_event_box);
+
+  gtk_widget_set_size_request (priv->output_frame,
+      OUTPUT_FRAME_INITIAL_WIDTH, OUTPUT_FRAME_INITIAL_HEIGHT);
   gtk_box_pack_start (GTK_BOX (priv->content_hbox),
-      priv->remote_user_output_frame, TRUE, TRUE,
+      priv->output_frame, TRUE, TRUE,
       CONTENT_HBOX_CHILDREN_PACKING_PADDING);
   empathy_call_window_setup_remote_frame (bus, self);
 
@@ -737,8 +770,12 @@ empathy_call_window_init (EmpathyCallWindow *self)
   priv->vbox = gtk_vbox_new (FALSE, 3);
   gtk_box_pack_start (GTK_BOX (priv->content_hbox), priv->vbox,
       FALSE, FALSE, CONTENT_HBOX_CHILDREN_PACKING_PADDING);
-  gtk_box_pack_start (GTK_BOX (priv->vbox), priv->self_user_output_frame, FALSE,
-      FALSE, 0);
+
+  /* The coordinate of the self_user_output_frame inside the output fixed
+      are properly set in empathy_call_window_place_output_widgets */
+  gtk_fixed_put (GTK_FIXED (priv->output_fixed), priv->self_user_output_frame,
+      0, 0);
+
   empathy_call_window_setup_self_frame (bus, self);
 
   g_object_unref (bus);
@@ -780,7 +817,8 @@ empathy_call_window_init (EmpathyCallWindow *self)
   gtk_widget_hide (priv->sidebar);
 
   priv->fullscreen = empathy_call_window_fullscreen_new (self);
-  empathy_call_window_fullscreen_set_video_widget (priv->fullscreen, priv->video_output);
+  empathy_call_window_fullscreen_set_output_section (priv->fullscreen,
+      priv->output_event_box);
   g_signal_connect (G_OBJECT (priv->fullscreen->leave_fullscreen_button),
       "clicked", G_CALLBACK (empathy_call_window_fullscreen_cb), self);
 
@@ -790,6 +828,9 @@ empathy_call_window_init (EmpathyCallWindow *self)
   g_signal_connect (G_OBJECT (self), "delete-event",
     G_CALLBACK (empathy_call_window_delete_cb), self);
 
+  g_signal_connect (G_OBJECT (self), "configure-event",
+    G_CALLBACK (empathy_call_window_configure_cb), self);
+
   g_signal_connect (G_OBJECT (self), "window-state-event",
     G_CALLBACK (empathy_call_window_state_event_cb), self);
 
@@ -1091,11 +1132,11 @@ empathy_call_window_finalize (GObject *object)
   EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (object);
   EmpathyCallWindowPriv *priv = GET_PRIV (self);
 
-  if (priv->video_output_motion_handler_id != 0)
+  if (priv->output_event_box_motion_handler_id != 0)
     {
-      g_signal_handler_disconnect (G_OBJECT (priv->video_output),
-          priv->video_output_motion_handler_id);
-      priv->video_output_motion_handler_id = 0;
+      g_signal_handler_disconnect (G_OBJECT (priv->output_event_box),
+          priv->output_event_box_motion_handler_id);
+      priv->output_event_box_motion_handler_id = 0;
     }
 
   /* free any data held directly by the object here */
@@ -1626,6 +1667,7 @@ empathy_call_window_update_avatars_visibility (EmpathyTpCall *call,
     }
 
   empathy_call_window_update_self_avatar_visibility (window);
+  empathy_call_window_place_output_widgets (window);
 }
 
 static void
@@ -1704,13 +1746,75 @@ show_borders (EmpathyCallWindow *window, gboolean set_fullscreen)
   gtk_box_set_spacing (GTK_BOX (priv->content_hbox),
       set_fullscreen ? 0 : CONTENT_HBOX_SPACING);
   gtk_box_set_child_packing (GTK_BOX (priv->content_hbox),
-      priv->video_output, TRUE, TRUE,
-      set_fullscreen ? 0 : CONTENT_HBOX_CHILDREN_PACKING_PADDING,
-      GTK_PACK_START);
-  gtk_box_set_child_packing (GTK_BOX (priv->content_hbox),
       priv->vbox, TRUE, TRUE,
       set_fullscreen ? 0 : CONTENT_HBOX_CHILDREN_PACKING_PADDING,
       GTK_PACK_START);
+
+  if (set_fullscreen)
+    {
+      gtk_widget_reparent (priv->output_event_box, priv->content_hbox);
+      gtk_widget_hide (priv->output_frame);
+    }
+  else
+    {
+      gtk_widget_show (priv->output_frame);
+      gtk_widget_reparent (priv->output_event_box, priv->output_frame);
+    }
+}
+
+static gboolean
+empathy_call_window_place_output_widgets (gpointer user_data)
+{
+  g_return_val_if_fail (EMPATHY_IS_CALL_WINDOW (user_data), FALSE);
+
+  EmpathyCallWindow *window = user_data;
+  EmpathyCallWindowPriv *priv = GET_PRIV (window);
+  GdkScreen *screen;
+  GdkRectangle screen_rect;
+  gint output_section_width, output_section_height;
+
+  screen = gtk_window_get_screen (GTK_WINDOW (window));
+  gdk_screen_get_monitor_geometry (screen,
+      gdk_screen_get_monitor_at_window (screen,
+          gtk_widget_get_window (GTK_WIDGET (window))), &screen_rect);
+
+  /* There is a small 5 pixels border between the edge of the output_frame and
+     the remote_user_output_hbox. The "- 5" in the size requisition
+     compensates for that */
+  gtk_widget_set_size_request (priv->remote_user_output_hbox,
+      priv->is_fullscreen ? screen_rect.width :
+        priv->output_frame->allocation.width - 5,
+      priv->is_fullscreen ? screen_rect.height :
+        priv->output_frame->allocation.height - 5);
+
+  output_section_width = priv->is_fullscreen ? screen_rect.width :
+    priv->output_frame->allocation.width;
+  output_section_height = priv->is_fullscreen ? screen_rect.height :
+      priv->output_frame->allocation.height;
+
+  gtk_fixed_move (GTK_FIXED (priv->output_fixed), priv->self_user_output_frame,
+      output_section_width - SELF_VIDEO_SECTION_WIDTH - VIDEO_PREVIEW_BORDER,
+      output_section_height - SELF_VIDEO_SECTION_HEIGTH - VIDEO_PREVIEW_BORDER);
+
+  if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (priv->show_preview)))
+    {
+      /* Refreshing the Z index of the self_user_output_frame to make sure
+         that it's on top of the video output. */
+      gtk_widget_hide (priv->self_user_output_frame);
+      gtk_widget_show (priv->self_user_output_frame);
+    }
+
+  return FALSE;
+}
+
+static gboolean
+empathy_call_window_configure_cb (GtkWidget *widget,
+  GdkEventConfigure *event, EmpathyCallWindow *window)
+{
+  /* We want to be sure that the window has finished resizing so we wait
+     for the other events to be completed before placing the widgets */
+  g_idle_add (empathy_call_window_place_output_widgets, window);
+  return FALSE;
 }
 
 static gboolean
@@ -1734,21 +1838,21 @@ empathy_call_window_state_event_cb (GtkWidget *widget,
           priv->original_width_before_fs = original_width;
           priv->original_height_before_fs = original_height;
 
-          if (priv->video_output_motion_handler_id == 0 &&
-                priv->video_output != NULL)
+          if (priv->output_event_box_motion_handler_id == 0 &&
+                priv->output_event_box != NULL)
             {
-              priv->video_output_motion_handler_id = g_signal_connect (
-                  G_OBJECT (priv->video_output), "motion-notify-event",
-                  G_CALLBACK (empathy_call_window_video_output_motion_notify), window);
+              priv->output_event_box_motion_handler_id = g_signal_connect (
+                  G_OBJECT (priv->output_event_box), "motion-notify-event",
+                  G_CALLBACK (empathy_call_window_output_motion_notify), window);
             }
         }
       else
         {
-          if (priv->video_output_motion_handler_id != 0)
+          if (priv->output_event_box_motion_handler_id != 0)
             {
-              g_signal_handler_disconnect (G_OBJECT (priv->video_output),
-                  priv->video_output_motion_handler_id);
-              priv->video_output_motion_handler_id = 0;
+              g_signal_handler_disconnect (G_OBJECT (priv->output_event_box),
+                  priv->output_event_box_motion_handler_id);
+              priv->output_event_box_motion_handler_id = 0;
             }
         }
 
@@ -1759,6 +1863,10 @@ empathy_call_window_state_event_cb (GtkWidget *widget,
       gtk_action_set_stock_id (priv->menu_fullscreen,
           (set_fullscreen ? "gtk-leave-fullscreen" : "gtk-fullscreen"));
       priv->is_fullscreen = set_fullscreen;
+
+      /* We want to be sure that the window has finished resizing so we wait
+         for the other events to be completed before placing the widgets */
+      g_idle_add (empathy_call_window_place_output_widgets, window);
   }
 
   return FALSE;
@@ -1872,6 +1980,7 @@ empathy_call_window_show_preview_toggled_cb (GtkToggleAction *toggle,
       empathy_call_window_setup_video_preview (window);
       gtk_widget_show (priv->self_user_output_frame);
       empathy_call_window_update_self_avatar_visibility (window);
+      empathy_call_window_place_output_widgets (window);
     }
   else
     {
@@ -1953,6 +2062,7 @@ empathy_call_window_restart_call (EmpathyCallWindow *window)
 
   empathy_call_window_setup_remote_frame (bus, window);
   empathy_call_window_setup_self_frame (bus, window);
+  empathy_call_window_place_output_widgets (window);
 
   g_object_unref (bus);
 
@@ -1990,7 +2100,7 @@ empathy_call_window_redial_cb (gpointer object,
 
 static void
 empathy_call_window_fullscreen_cb (gpointer object,
-                                   EmpathyCallWindow *window)
+  EmpathyCallWindow *window)
 {
   empathy_call_window_fullscreen_toggle (window);
 }
@@ -2037,7 +2147,7 @@ empathy_call_window_key_press_cb (GtkWidget *video_output,
 }
 
 static gboolean
-empathy_call_window_video_output_motion_notify (GtkWidget *widget,
+empathy_call_window_output_motion_notify (GtkWidget *widget,
     GdkEventMotion *event, EmpathyCallWindow *window)
 {
   EmpathyCallWindowPriv *priv = GET_PRIV (window);
