src/empathy-call-window-fullscreen.c

   1 /*
   2  * empathy-call-window-fullscreen.c - Source for EmpathyCallWindowFullscreen
   3  * Copyright (C) 2009 Collabora Ltd.
   4  *
   5  * Some code is based on the Totem Movie Player, especially
   6  * totem-fullscreen.c which has the following copyright:
   7  * Copyright (C) 2001-2007 Bastien Nocera <hadess@hadess.net>
   8  * Copyright (C) 2007 Sunil Mohan Adapa <sunilmohan@gnu.org.in>
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23  */
  24
  25 #include "empathy-call-window-fullscreen.h"
  26
  27 #include <gtk/gtk.h>
  28
  29 #include <libempathy/empathy-utils.h>
  30 #include <libempathy-gtk/empathy-ui-utils.h>
  31
  32 /* The number of seconds for which the "leave fullscreen" popup should
  33    be shown */
  34 #define FULLSCREEN_POPUP_TIMEOUT 5
  35
  36 G_DEFINE_TYPE (EmpathyCallWindowFullscreen, empathy_call_window_fullscreen,
  37     G_TYPE_OBJECT)
  38
  39 /* private structure */
  40 typedef struct _EmpathyCallWindowFullscreenPriv
  41     EmpathyCallWindowFullscreenPriv;
  42
  43 struct _EmpathyCallWindowFullscreenPriv
  44 {
  45   EmpathyCallWindow *parent_window;
  46
  47   GtkWidget *leave_fullscreen_popup;
  48   GtkWidget *video_widget;
  49
  50   guint popup_timeout;
  51   gboolean popup_creation_in_progress;
  52   gboolean dispose_has_run;
  53 };
  54
  55 #define GET_PRIV(o) \
  56   (G_TYPE_INSTANCE_GET_PRIVATE ((o), EMPATHY_TYPE_CALL_WINDOW_FULLSCREEN, \
  57     EmpathyCallWindowFullscreenPriv))
  58
  59 static void empathy_call_window_fullscreen_dispose (GObject *object);
  60 static void empathy_call_window_fullscreen_finalize (GObject *object);
  61
  62 static gboolean empathy_call_window_fullscreen_hide_popup (
  63     EmpathyCallWindowFullscreen *fs);
  64
  65 static void
  66 empathy_call_window_fullscreen_set_cursor_visible (
  67     EmpathyCallWindowFullscreen *fs,
  68     gboolean show_cursor)
  69 {
  70   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (fs);
  71
  72   if (priv->video_widget != NULL && !show_cursor)
  73     {
  74       gdk_window_set_cursor (gtk_widget_get_window (priv->video_widget),
  75           gdk_cursor_new (GDK_BLANK_CURSOR));
  76     }
  77   else
  78     gdk_window_set_cursor (gtk_widget_get_window (priv->video_widget), NULL);
  79 }
  80
  81 static void
  82 empathy_call_window_fullscreen_add_popup_timeout (
  83     EmpathyCallWindowFullscreen *self)
  84 {
  85   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (self);
  86
  87   if (priv->popup_timeout == 0)
  88     {
  89       priv->popup_timeout = g_timeout_add_seconds (FULLSCREEN_POPUP_TIMEOUT,
  90           (GSourceFunc) empathy_call_window_fullscreen_hide_popup, self);
  91     }
  92 }
  93
  94 static void
  95 empathy_call_window_fullscreen_remove_popup_timeout (
  96     EmpathyCallWindowFullscreen *self)
  97 {
  98   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (self);
  99
 100   if (priv->popup_timeout != 0)
 101     {
 102       g_source_remove (priv->popup_timeout);
 103       priv->popup_timeout = 0;
 104     }
 105 }
 106
 107 void
 108 empathy_call_window_fullscreen_show_popup (EmpathyCallWindowFullscreen *self)
 109 {
 110   gint leave_fullscreen_width, leave_fullscreen_height;
 111   GdkScreen *screen;
 112   GdkRectangle fullscreen_rect;
 113   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (self);
 114
 115   g_assert (self->is_fullscreen);
 116
 117   g_return_if_fail (priv->parent_window != NULL);
 118
 119   if (priv->popup_creation_in_progress)
 120     return;
 121
 122   if (!gtk_window_is_active (GTK_WINDOW (priv->parent_window)))
 123     return;
 124
 125   priv->popup_creation_in_progress = TRUE;
 126
 127   empathy_call_window_fullscreen_set_cursor_visible (self, TRUE);
 128
 129   /* Obtaining the screen rectangle */
 130   screen = gtk_window_get_screen (GTK_WINDOW (priv->parent_window));
 131   gdk_screen_get_monitor_geometry (screen,
 132       gdk_screen_get_monitor_at_window (screen,
 133           gtk_widget_get_window (GTK_WIDGET (priv->parent_window))),
 134       &fullscreen_rect);
 135
 136   /* Getting the popup window sizes */
 137   gtk_window_get_size (GTK_WINDOW (priv->leave_fullscreen_popup),
 138       &leave_fullscreen_width, &leave_fullscreen_height);
 139
 140   /* Moving the popup to the top-right corner (if the direction is LTR) or the
 141      top-left corner (if the direction is RTL).*/
 142   if (gtk_widget_get_direction (priv->leave_fullscreen_popup)
 143         == GTK_TEXT_DIR_LTR)
 144     {
 145       gtk_window_move (GTK_WINDOW (priv->leave_fullscreen_popup),
 146           fullscreen_rect.width + fullscreen_rect.x - leave_fullscreen_width,
 147           fullscreen_rect.y);
 148
 149     }
 150   else
 151     {
 152       gtk_window_move (GTK_WINDOW (priv->leave_fullscreen_popup),
 153           fullscreen_rect.x, fullscreen_rect.y);
 154     }
 155
 156   gtk_widget_show_all (priv->leave_fullscreen_popup);
 157   empathy_call_window_fullscreen_add_popup_timeout (self);
 158
 159   priv->popup_creation_in_progress = FALSE;
 160 }
 161
 162 static gboolean
 163 empathy_call_window_fullscreen_hide_popup (EmpathyCallWindowFullscreen *fs)
 164 {
 165   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (fs);
 166
 167   if (priv->video_widget == NULL || !fs->is_fullscreen)
 168     return TRUE;
 169
 170   gtk_widget_hide (priv->leave_fullscreen_popup);
 171   empathy_call_window_fullscreen_remove_popup_timeout (fs);
 172
 173   empathy_call_window_fullscreen_set_cursor_visible (fs, FALSE);
 174
 175   return FALSE;
 176 }
 177
 178 static void
 179 empathy_call_window_fullscreen_init (EmpathyCallWindowFullscreen *self)
 180 {
 181   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (self);
 182   GtkBuilder *gui;
 183   gchar *filename;
 184
 185   filename = empathy_file_lookup ("empathy-call-window-fullscreen.ui", "src");
 186   gui = empathy_builder_get_file (filename,
 187     "leave_fullscreen_window", &priv->leave_fullscreen_popup,
 188     "leave_fullscreen_button", &self->leave_fullscreen_button,
 189     NULL);
 190
 191   gtk_widget_add_events (priv->leave_fullscreen_popup, GDK_POINTER_MOTION_MASK);
 192
 193   g_object_unref (gui);
 194   g_free (filename);
 195 }
 196
 197 static void
 198 empathy_call_window_fullscreen_class_init (
 199     EmpathyCallWindowFullscreenClass *klass)
 200 {
 201   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 202
 203   g_type_class_add_private (klass, sizeof (EmpathyCallWindowFullscreenPriv));
 204
 205   object_class->dispose = empathy_call_window_fullscreen_dispose;
 206   object_class->finalize = empathy_call_window_fullscreen_finalize;
 207 }
 208
 209 void
 210 empathy_call_window_fullscreen_dispose (GObject *object)
 211 {
 212   EmpathyCallWindowFullscreen *self = EMPATHY_CALL_WINDOW_FULLSCREEN (object);
 213   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (self);
 214
 215   if (priv->dispose_has_run)
 216     return;
 217
 218   priv->dispose_has_run = TRUE;
 219
 220   if (priv->leave_fullscreen_popup != NULL)
 221     gtk_widget_destroy (priv->leave_fullscreen_popup);
 222   priv->leave_fullscreen_popup = NULL;
 223
 224   if (G_OBJECT_CLASS (empathy_call_window_fullscreen_parent_class)->dispose)
 225     {
 226       G_OBJECT_CLASS (
 227           empathy_call_window_fullscreen_parent_class)->dispose (object);
 228     }
 229 }
 230
 231 void
 232 empathy_call_window_fullscreen_finalize (GObject *object)
 233 {
 234   EmpathyCallWindowFullscreen *self = EMPATHY_CALL_WINDOW_FULLSCREEN (object);
 235
 236   empathy_call_window_fullscreen_remove_popup_timeout (self);
 237
 238   G_OBJECT_CLASS (
 239       empathy_call_window_fullscreen_parent_class)->finalize (object);
 240 }
 241
 242 static void
 243 empathy_call_window_fullscreen_parent_window_notify (GtkWidget *parent_window,
 244     GParamSpec *property, EmpathyCallWindowFullscreen *fs)
 245 {
 246   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (fs);
 247
 248   if (!fs->is_fullscreen)
 249     return;
 250
 251   if (parent_window == GTK_WIDGET (priv->parent_window) &&
 252         !gtk_window_is_active (GTK_WINDOW (parent_window)))
 253     {
 254       empathy_call_window_fullscreen_hide_popup (fs);
 255       empathy_call_window_fullscreen_set_cursor_visible (fs, TRUE);
 256     }
 257 }
 258
 259 EmpathyCallWindowFullscreen *
 260 empathy_call_window_fullscreen_new (EmpathyCallWindow *parent_window)
 261 {
 262   EmpathyCallWindowFullscreen *self = EMPATHY_CALL_WINDOW_FULLSCREEN (
 263     g_object_new (EMPATHY_TYPE_CALL_WINDOW_FULLSCREEN, NULL));
 264   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (self);
 265
 266   priv->parent_window = parent_window;
 267   g_signal_connect (G_OBJECT (priv->parent_window), "notify::is-active",
 268     G_CALLBACK (empathy_call_window_fullscreen_parent_window_notify), self);
 269
 270   return self;
 271 }
 272
 273 void
 274 empathy_call_window_fullscreen_set_fullscreen (EmpathyCallWindowFullscreen *fs,
 275   gboolean set_fullscreen)
 276 {
 277
 278   if (set_fullscreen)
 279       empathy_call_window_fullscreen_remove_popup_timeout (fs);
 280   else
 281       empathy_call_window_fullscreen_hide_popup (fs);
 282
 283   empathy_call_window_fullscreen_set_cursor_visible (fs, !set_fullscreen);
 284   fs->is_fullscreen = set_fullscreen;
 285 }
 286
 287 void
 288 empathy_call_window_fullscreen_set_video_widget (
 289     EmpathyCallWindowFullscreen *fs,
 290     GtkWidget *video_widget)
 291 {
 292   EmpathyCallWindowFullscreenPriv *priv = GET_PRIV (fs);
 293   priv->video_widget = video_widget;
 294 }