← Back to branch summary

~ubuntu-branches/debian/sid/cheese/sid

« back to all changes in this revision

Viewing changes to src/cheese-window.c

  • Committer: Bazaar Package Importer
  • Author(s): Andrea Veri, Andrea Veri, Loïc Minier
  • Date: 2009-09-23 20:25:41 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20090923202541-q9lr8b7ykic314xy
Tags: 2.28.0.1-1
[ Andrea Veri ]
* New upstream release.
* debian/control:
  - Bumped Standards-version to 3.8.3. No changes needed.
  - libgtk2.0-dev bumped to >= 2.17.4 as per configure.ac
    requirements.
  - libgnome-desktop-dev bumped to >= 2.26.0 as per configure.ac
    requirements.
  - added a B-D on x11proto-core-dev needed from multimedia keys
    to work properly.
* debian/copyright:
  - added missing copyright holders.
* debian/patches:
  - removed as long as it has no patches in it.
* debian/rules:
  - simple-patchsys include removed, there are no patches to be
    applied.

[ Loïc Minier ]
* Bdep on rarian-compat instead of scrollkeeper.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cheese-window.c
1
1
/*
2
 
 * Copyright © 2007,2008 daniel g. siegel <dgsiegel@gmail.com>
 
2
 * Copyright © 2007,2008 daniel g. siegel <dgsiegel@gnome.org>
3
3
 * Copyright © 2007,2008 Jaap Haitsma <jaap@haitsma.org>
4
4
 * Copyright © 2008 Patryk Zawadzki <patrys@pld-linux.org>
5
5
 * Copyright © 2008 Ryan Zeigler <zeiglerr@gmail.com>
39
39
#include <gtk/gtk.h>
40
40
#include <libebook/e-book.h>
41
41
 
42
 
#ifdef HILDON
43
 
  #include <hildon/hildon-program.h>
44
 
#endif
 
42
#ifdef HAVE_MMKEYS
 
43
  #include <X11/XF86keysym.h>
 
44
#endif /* HAVE_MMKEYS */
45
45
 
46
46
#include "cheese-countdown.h"
47
47
#include "cheese-effect-chooser.h"
52
52
#include "cheese-window.h"
53
53
#include "ephy-spinner.h"
54
54
#include "gst-audio-play.h"
55
 
#include "gedit-message-area.h"
56
55
#include "cheese-no-camera.h"
57
56
#include "cheese-prefs-dialog.h"
58
57
#include "cheese-flash.h"
61
60
#define FULLSCREEN_POPUP_HEIGHT    40
62
61
#define FULLSCREEN_TIMEOUT         5 * 1000
63
62
#define FULLSCREEN_EFFECTS_TIMEOUT 15
 
63
#define DEFAULT_WINDOW_WIDTH       600
 
64
#define DEFAULT_WINDOW_HEIGHT      450
64
65
 
65
66
typedef enum
66
67
{
67
68
  WEBCAM_MODE_PHOTO,
68
 
  WEBCAM_MODE_VIDEO
 
69
  WEBCAM_MODE_VIDEO,
 
70
  WEBCAM_MODE_BURST
69
71
} WebcamMode;
70
72
 
71
73
typedef enum
108
110
  GtkWidget *main_vbox;
109
111
  GtkWidget *video_vbox;
110
112
 
 
113
  GtkWidget *netbook_alignment;
 
114
  GtkWidget *toolbar_alignment;
 
115
  GtkWidget *effect_button_alignment;
 
116
  GtkWidget *togglegroup_alignment;
 
117
 
111
118
  GtkWidget *effect_frame;
112
119
  GtkWidget *effect_alignment;
113
120
  GtkWidget *effect_chooser;
117
124
  GtkWidget *countdown_frame_fullscreen;
118
125
  GtkWidget *countdown;
119
126
  GtkWidget *countdown_fullscreen;
120
 
  GtkWidget *message_area_frame;
121
 
  GtkWidget *message_area;
 
127
  GtkWidget *info_bar_frame;
 
128
  GtkWidget *info_bar;
122
129
 
123
130
  GtkWidget *button_effects;
124
131
  GtkWidget *button_photo;
125
132
  GtkWidget *button_video;
 
133
  GtkWidget *button_burst;
126
134
  GtkWidget *button_effects_fullscreen;
127
135
  GtkWidget *button_photo_fullscreen;
128
136
  GtkWidget *button_video_fullscreen;
 
137
  GtkWidget *button_burst_fullscreen;
129
138
  GtkWidget *button_exit_fullscreen;
130
139
 
131
140
  GtkWidget *image_take_photo;
147
156
  GtkWidget *take_picture;
148
157
  GtkWidget *take_picture_fullscreen;
149
158
 
150
 
#ifdef HILDON
151
 
  GtkWidget *main_hbox;
152
 
  GtkWidget *subwindow;
153
 
#endif
154
 
 
155
159
  GtkActionGroup *actions_account_photo;
156
160
  GtkActionGroup *actions_countdown;
157
161
  GtkActionGroup *actions_effects;
165
169
  GtkActionGroup *actions_photo;
166
170
  GtkActionGroup *actions_toggle;
167
171
  GtkActionGroup *actions_video;
 
172
  GtkActionGroup *actions_burst;
168
173
  GtkActionGroup *actions_fullscreen;
 
174
  GtkActionGroup *actions_wide_mode;
169
175
 
170
176
  GtkUIManager *ui_manager;
171
177
 
173
179
 
174
180
  int audio_play_counter;
175
181
 
 
182
  gint repeat_count;
 
183
  gboolean is_bursting;
 
184
 
176
185
  CheeseFlash *flash;
177
186
} CheeseWindow;
178
187
 
 
188
static void cheese_window_action_button_clicked_cb (GtkWidget *widget, CheeseWindow *cheese_window);
 
189
 
179
190
void
180
191
cheese_window_bring_to_front (gpointer data)
181
192
{
182
193
  CheeseWindow *cheese_window     = data;
183
 
  guint32       startup_timestamp = gdk_x11_get_server_time (GTK_WIDGET (cheese_window->window)->window);
 
194
  guint32       startup_timestamp = gdk_x11_get_server_time (gtk_widget_get_window (GTK_WIDGET (cheese_window->window)));
184
195
 
185
 
  gdk_x11_window_set_user_time (GTK_WIDGET (cheese_window->window)->window, startup_timestamp);
 
196
  gdk_x11_window_set_user_time (gtk_widget_get_window (GTK_WIDGET (cheese_window->window)), startup_timestamp);
186
197
 
187
198
  gtk_window_present (GTK_WINDOW (cheese_window->window));
188
199
}
189
200
 
190
 
/* Make url in about dialog clickable */
191
 
static void
192
 
cheese_about_dialog_handle_url (GtkAboutDialog *dialog, const char *url, gpointer data)
193
 
{
194
 
  GError    *error = NULL;
195
 
  GtkWidget *error_dialog;
196
 
  GdkScreen *screen;
197
 
 
198
 
  screen = gtk_widget_get_screen (GTK_WIDGET (dialog));
199
 
  gtk_show_uri (screen, url, gtk_get_current_event_time (), &error);
200
 
  if (error != NULL)
201
 
  {
202
 
    error_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
203
 
                                           GTK_DIALOG_DESTROY_WITH_PARENT,
204
 
                                           GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
205
 
                                           _("Failed to open browser to show:\n%s"), url);
206
 
    gtk_dialog_run (GTK_DIALOG (error_dialog));
207
 
    gtk_widget_destroy (error_dialog);
208
 
    g_error_free (error);
209
 
  }
210
 
}
211
 
 
212
 
/* Make email in about dialog clickable */
213
 
static void
214
 
cheese_about_dialog_handle_email (GtkAboutDialog *dialog, const char *email, gpointer data)
215
 
{
216
 
  char      *uri;
217
 
  GError    *error = NULL;
218
 
  GtkWidget *error_dialog;
219
 
  GdkScreen *screen;
220
 
 
221
 
  uri = g_strconcat ("mailto:", email, NULL);
222
 
 
223
 
  screen = gtk_widget_get_screen (GTK_WIDGET (dialog));
224
 
  gtk_show_uri (screen, uri, gtk_get_current_event_time (), &error);
225
 
  if (error != NULL)
226
 
  {
227
 
    error_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
228
 
                                           GTK_DIALOG_DESTROY_WITH_PARENT,
229
 
                                           GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
230
 
                                           _("Failed to open email client to send message to:\n%s"), email);
231
 
    gtk_dialog_run (GTK_DIALOG (error_dialog));
232
 
    gtk_widget_destroy (error_dialog);
233
 
    g_error_free (error);
234
 
  }
235
 
  g_free (uri);
236
 
}
237
 
 
238
201
static char *
239
202
audio_play_get_filename (CheeseWindow *cheese_window)
240
203
{
258
221
  return FALSE;
259
222
}
260
223
 
 
224
static gboolean
 
225
cheese_window_key_press_event_cb (GtkWidget *win, GdkEventKey *event, CheeseWindow *cheese_window)
 
226
{
 
227
#ifndef HAVE_MMKEYS
 
228
  return FALSE;
 
229
#else
 
230
  /* If we have modifiers, and either Ctrl, Mod1 (Alt), or any
 
231
   * of Mod3 to Mod5 (Mod2 is num-lock...) are pressed, we
 
232
   * let Gtk+ handle the key */
 
233
  if (event->state != 0
 
234
      && ((event->state & GDK_CONTROL_MASK)
 
235
          || (event->state & GDK_MOD1_MASK)
 
236
          || (event->state & GDK_MOD3_MASK)
 
237
          || (event->state & GDK_MOD4_MASK)
 
238
          || (event->state & GDK_MOD5_MASK)))
 
239
    return FALSE;
 
240
 
 
241
  switch (event->keyval)
 
242
  {
 
243
    case XF86XK_WebCam:
 
244
 
 
245
      /* do stuff */
 
246
      cheese_window_action_button_clicked_cb (NULL, cheese_window);
 
247
      return TRUE;
 
248
  }
 
249
 
 
250
  return FALSE;
 
251
#endif /* !HAVE_MMKEYS */
 
252
}
 
253
 
261
254
static void
262
255
cheese_window_fullscreen_clear_timeout (CheeseWindow *cheese_window)
263
256
{
288
281
  GSource *source;
289
282
 
290
283
  cheese_window_fullscreen_clear_timeout (cheese_window);
291
 
  
 
284
 
292
285
  source = g_timeout_source_new (FULLSCREEN_TIMEOUT);
293
286
 
294
287
  g_source_set_callback (source, cheese_window_fullscreen_timeout_cb, cheese_window, NULL);
322
315
    {
323
316
      cheese_window_fullscreen_show_bar (cheese_window);
324
317
    }
325
 
    
326
 
    //don't set the timeout in effect-chooser mode
 
318
 
 
319
    /* don't set the timeout in effect-chooser mode */
327
320
    if (gtk_notebook_get_current_page (GTK_NOTEBOOK (cheese_window->notebook)) != 1)
328
321
      cheese_window_fullscreen_set_timeout (cheese_window);
329
322
  }
331
324
}
332
325
 
333
326
static void
 
327
cheese_window_toggle_wide_mode (GtkWidget *widget, CheeseWindow *cheese_window)
 
328
{
 
329
  gboolean toggled = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (widget));
 
330
 
 
331
  gtk_widget_set_size_request (cheese_window->notebook,
 
332
                               GTK_WIDGET (cheese_window->notebook)->allocation.width,
 
333
                               GTK_WIDGET (cheese_window->notebook)->allocation.height);
 
334
 
 
335
  /* set a single column in wide mode */
 
336
  gtk_icon_view_set_columns (GTK_ICON_VIEW (cheese_window->thumb_view), toggled ? 1 : G_MAXINT);
 
337
 
 
338
  /* switch thumb_nav mode */
 
339
  eog_thumb_nav_set_vertical (EOG_THUMB_NAV (cheese_window->thumb_nav), toggled);
 
340
 
 
341
  /* reparent thumb_view */
 
342
  g_object_ref (cheese_window->thumb_scrollwindow);
 
343
  if (toggled)
 
344
  {
 
345
    gtk_container_remove (GTK_CONTAINER (cheese_window->video_vbox), cheese_window->thumb_scrollwindow);
 
346
    gtk_container_add (GTK_CONTAINER (cheese_window->netbook_alignment), cheese_window->thumb_scrollwindow);
 
347
    g_object_unref (cheese_window->thumb_scrollwindow);
 
348
  }
 
349
  else
 
350
  {
 
351
    gtk_container_remove (GTK_CONTAINER (cheese_window->netbook_alignment), cheese_window->thumb_scrollwindow);
 
352
    gtk_box_pack_end (GTK_BOX (cheese_window->video_vbox), cheese_window->thumb_scrollwindow, FALSE, FALSE, 0);
 
353
    g_object_unref (cheese_window->thumb_scrollwindow);
 
354
    eog_thumb_nav_set_policy (EOG_THUMB_NAV (cheese_window->thumb_nav),
 
355
                              GTK_POLICY_AUTOMATIC,
 
356
                              GTK_POLICY_NEVER);
 
357
  }
 
358
 
 
359
  /* update spacing */
 
360
 
 
361
  /* NOTE: be really carefull when changing the ui file to update spacing
 
362
   * values here too! */
 
363
  if (toggled)
 
364
  {
 
365
    g_object_set (G_OBJECT (cheese_window->toolbar_alignment),
 
366
                  "bottom-padding", 10, NULL);
 
367
    g_object_set (G_OBJECT (cheese_window->togglegroup_alignment),
 
368
                  "left-padding", 6, NULL);
 
369
    g_object_set (G_OBJECT (cheese_window->effect_button_alignment),
 
370
                  "right-padding", 0, NULL);
 
371
    g_object_set (G_OBJECT (cheese_window->netbook_alignment),
 
372
                  "left-padding", 6, NULL);
 
373
  }
 
374
  else
 
375
  {
 
376
    g_object_set (G_OBJECT (cheese_window->toolbar_alignment),
 
377
                  "bottom-padding", 6, NULL);
 
378
    g_object_set (G_OBJECT (cheese_window->togglegroup_alignment),
 
379
                  "left-padding", 24, NULL);
 
380
    g_object_set (G_OBJECT (cheese_window->effect_button_alignment),
 
381
                  "right-padding", 24, NULL);
 
382
    g_object_set (G_OBJECT (cheese_window->netbook_alignment),
 
383
                  "left-padding", 0, NULL);
 
384
  }
 
385
 
 
386
  gtk_container_resize_children (GTK_CONTAINER (cheese_window->thumb_scrollwindow));
 
387
 
 
388
  GtkRequisition req;
 
389
  gtk_widget_size_request (cheese_window->window, &req);
 
390
  gtk_window_resize (GTK_WINDOW (cheese_window->window), req.width, req.height);
 
391
  gtk_widget_set_size_request (cheese_window->notebook, -1, -1);
 
392
 
 
393
  g_object_set (cheese_window->gconf, "gconf_prop_wide_mode", toggled, NULL);
 
394
}
 
395
 
 
396
static void
334
397
cheese_window_toggle_fullscreen (GtkWidget *widget, CheeseWindow *cheese_window)
335
398
{
336
399
  GdkColor   bg_color = {0, 0, 0, 0};
357
420
                      cheese_window);
358
421
 
359
422
    gtk_window_fullscreen (GTK_WINDOW (cheese_window->window));
360
 
    
 
423
 
361
424
    gtk_widget_set_size_request (cheese_window->effect_alignment, -1, FULLSCREEN_POPUP_HEIGHT);
362
425
    cheese_window_fullscreen_show_bar (cheese_window);
363
 
    
364
 
    //don't set the timeout in effect-chooser mode
 
426
 
 
427
    /* don't set the timeout in effect-chooser mode */
365
428
    if (gtk_notebook_get_current_page (GTK_NOTEBOOK (cheese_window->notebook)) != 1)
366
429
      cheese_window_fullscreen_set_timeout (cheese_window);
367
430
 
372
435
    gtk_widget_show_all (cheese_window->window);
373
436
    gtk_widget_hide_all (cheese_window->fullscreen_popup);
374
437
    gtk_widget_modify_bg (cheese_window->window, GTK_STATE_NORMAL, NULL);
375
 
    
 
438
 
376
439
    g_signal_handlers_disconnect_by_func (cheese_window->window,
377
440
                                          (gpointer) cheese_window_fullscreen_motion_notify_cb, cheese_window);
378
441
    g_signal_handlers_disconnect_by_func (cheese_window->screen,
407
470
cheese_window_photo_saved_cb (CheeseWebcam *webcam, CheeseWindow *cheese_window)
408
471
{
409
472
  gdk_threads_enter ();
410
 
  gtk_widget_set_sensitive (cheese_window->take_picture, TRUE);
411
 
  gtk_widget_set_sensitive (cheese_window->take_picture_fullscreen, TRUE);
 
473
  if (!cheese_window->is_bursting)
 
474
  {
 
475
    gtk_action_group_set_sensitive (cheese_window->actions_effects, TRUE);
 
476
    gtk_action_group_set_sensitive (cheese_window->actions_toggle, TRUE);
 
477
    gtk_widget_set_sensitive (cheese_window->take_picture, TRUE);
 
478
    gtk_widget_set_sensitive (cheese_window->take_picture_fullscreen, TRUE);
 
479
  }
412
480
  gdk_flush ();
413
481
  gdk_threads_leave ();
414
482
}
415
483
 
416
 
 
417
484
static void
418
485
cheese_window_video_saved_cb (CheeseWebcam *webcam, CheeseWindow *cheese_window)
419
486
{
420
487
  gdk_threads_enter ();
 
488
 
421
489
  /* TODO look at this g_free */
422
490
  g_free (cheese_window->video_filename);
423
491
  cheese_window->video_filename = NULL;
447
515
  g_object_unref (cheese_window->actions_preferences);
448
516
  g_object_unref (cheese_window->actions_file);
449
517
  g_object_unref (cheese_window->actions_video);
 
518
  g_object_unref (cheese_window->actions_burst);
450
519
  g_object_unref (cheese_window->actions_fullscreen);
451
520
  g_object_unref (cheese_window->gconf);
452
521
 
476
545
    dialog = gtk_message_dialog_new (GTK_WINDOW (cheese_window->window),
477
546
                                     GTK_DIALOG_DESTROY_WITH_PARENT,
478
547
                                     GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
479
 
                                     _("Failed to launch program to show:\n%s"), uri);
 
548
                                     _("Failed to launch program to show:\n"
 
549
                                       "%s\n"
 
550
                                       "%s"), uri, error->message);
480
551
    gtk_dialog_run (GTK_DIALOG (dialog));
481
552
    gtk_widget_destroy (dialog);
482
553
    g_error_free (error);
938
1009
static void
939
1010
cheese_window_cmd_help_contents (GtkAction *action, CheeseWindow *cheese_window)
940
1011
{
941
 
  GError  *error = NULL;
 
1012
  GError    *error = NULL;
942
1013
  GdkScreen *screen;
943
1014
 
944
1015
  screen = gtk_widget_get_screen (GTK_WIDGET (cheese_window));
961
1032
cheese_window_cmd_about (GtkAction *action, CheeseWindow *cheese_window)
962
1033
{
963
1034
  static const char *authors[] = {
964
 
    "daniel g. siegel <dgsiegel@gmail.com>",
 
1035
    "daniel g. siegel <dgsiegel@gnome.org>",
965
1036
    "Jaap A. Haitsma <jaap@haitsma.org>",
 
1037
    "Filippo Argiolas <fargiolas@gnome.org>",
966
1038
    "",
 
1039
    "Aidan Delaney <a.j.delaney@brighton.ac.uk>",
967
1040
    "Alex \"weej\" Jones <alex@weej.com>",
968
1041
    "Andrea Cimitan <andrea.cimitan@gmail.com>",
969
1042
    "Baptiste Mille-Mathias <bmm80@free.fr>",
970
1043
    "Cosimo Cecchi <anarki@lilik.it>",
971
1044
    "Diego Escalante Urrelo <dieguito@gmail.com>",
972
1045
    "Felix Kaser <f.kaser@gmx.net>",
973
 
    "Filippo Argiolas <filippo.argiolas@gmail.com>",
974
1046
    "Gintautas Miliauskas <gintas@akl.lt>",
 
1047
    "Hans de Goede <jwrdegoede@fedoraproject.org>",
975
1048
    "James Liggett <jrliggett@cox.net>",
976
1049
    "Luca Ferretti <elle.uca@libero.it>",
977
1050
    "Mirco \"MacSlow\" Müller <macslow@bangang.de>",
992
1065
    "Kalle Persson <kalle@kallepersson.se>",
993
1066
    "Lapo Calamandrei <calamandrei@gmail.com>",
994
1067
    "Or Dvory <gnudles@nana.co.il>",
 
1068
    "Ulisse Perusin <ulisail@yahoo.it>",
995
1069
    NULL
996
1070
  };
997
1071
 
998
1072
  static const char *documenters[] = {
999
1073
    "Joshua Henderson <joshhendo@gmail.com>",
 
1074
    "Jaap A. Haitsma <jaap@haitsma.org>",
1000
1075
    NULL
1001
1076
  };
1002
1077
 
1023
1098
 
1024
1099
  gtk_show_about_dialog (GTK_WINDOW (cheese_window->window),
1025
1100
                         "version", VERSION,
1026
 
                         "copyright", "Copyright \xc2\xa9 2007, 2008\n daniel g. siegel <dgsiegel@gmail.com>",
 
1101
                         "copyright", "Copyright \xc2\xa9 2007 - 2009\n daniel g. siegel <dgsiegel@gnome.org>",
1027
1102
                         "comments", _("Take photos and videos with your webcam, with fun graphical effects"),
1028
1103
                         "authors", authors,
1029
1104
                         "translator-credits", translators,
1155
1230
    {
1156
1231
      gtk_action_group_set_sensitive (cheese_window->actions_photo, TRUE);
1157
1232
    }
 
1233
    else if (cheese_window->webcam_mode == WEBCAM_MODE_BURST)
 
1234
    {
 
1235
      gtk_action_group_set_sensitive (cheese_window->actions_burst, TRUE);
 
1236
    }
1158
1237
    else
1159
1238
    {
1160
1239
      gtk_action_group_set_sensitive (cheese_window->actions_video, TRUE);
1172
1251
    gtk_widget_set_sensitive (GTK_WIDGET (cheese_window->take_picture_fullscreen), FALSE);
1173
1252
    gtk_action_group_set_sensitive (cheese_window->actions_photo, FALSE);
1174
1253
    gtk_action_group_set_sensitive (cheese_window->actions_video, FALSE);
 
1254
    gtk_action_group_set_sensitive (cheese_window->actions_burst, FALSE);
1175
1255
  }
1176
1256
}
1177
1257
 
1198
1278
  {
1199
1279
    cheese_flash_fire (cheese_window->flash);
1200
1280
    shutter_filename = audio_play_get_filename (cheese_window);
1201
 
    audio_play = gst_audio_play_file (shutter_filename, &error);
 
1281
    audio_play       = gst_audio_play_file (shutter_filename, &error);
1202
1282
    if (!audio_play)
1203
1283
    {
1204
1284
      g_warning ("%s", error ? error->message : "Unknown error");
1210
1290
}
1211
1291
 
1212
1292
static void
1213
 
cheese_window_no_camera_message_area_response (GtkWidget *widget, gint response_id, GtkWidget *cheese_window)
 
1293
cheese_window_no_camera_info_bar_response (GtkWidget *widget, gint response_id, CheeseWindow *cheese_window)
1214
1294
{
1215
1295
  GError  *error = NULL;
1216
1296
  gboolean ret;
1282
1362
    gtk_widget_set_sensitive (cheese_window->take_picture, TRUE);
1283
1363
    gtk_widget_set_sensitive (cheese_window->take_picture_fullscreen, TRUE);
1284
1364
  }
 
1365
  else if (cheese_window->webcam_mode == WEBCAM_MODE_BURST)
 
1366
  {
 
1367
    cheese_window->repeat_count = 0;
 
1368
    cheese_window->is_bursting  = FALSE;
 
1369
 
 
1370
    gtk_notebook_set_current_page (GTK_NOTEBOOK (cheese_window->notebook_bar), 0);
 
1371
    gtk_notebook_set_current_page (GTK_NOTEBOOK (cheese_window->fullscreen_bar), 0);
 
1372
 
 
1373
    gtk_action_group_set_sensitive (cheese_window->actions_effects, TRUE);
 
1374
    gtk_action_group_set_sensitive (cheese_window->actions_toggle, TRUE);
 
1375
 
 
1376
    gtk_widget_set_sensitive (cheese_window->take_picture, TRUE);
 
1377
    gtk_widget_set_sensitive (cheese_window->take_picture_fullscreen, TRUE);
 
1378
  }
1285
1379
  else
1286
1380
  {
1287
1381
    cheese_window_stop_recording (cheese_window);
1289
1383
  return TRUE;
1290
1384
}
1291
1385
 
 
1386
static gboolean
 
1387
cheese_window_take_photo (gpointer data)
 
1388
{
 
1389
  gboolean      countdown;
 
1390
  CheeseWindow *cheese_window = (CheeseWindow *) data;
 
1391
 
 
1392
  /* return if burst mode was cancelled */
 
1393
  if (cheese_window->webcam_mode == WEBCAM_MODE_BURST &&
 
1394
      !cheese_window->is_bursting && cheese_window->repeat_count <= 0)
 
1395
  {
 
1396
    return FALSE;
 
1397
  }
 
1398
 
 
1399
  g_object_get (cheese_window->gconf, "gconf_prop_countdown", &countdown, NULL);
 
1400
  if (countdown)
 
1401
  {
 
1402
    if (cheese_window->isFullscreen)
 
1403
    {
 
1404
      cheese_countdown_start ((CheeseCountdown *) cheese_window->countdown_fullscreen,
 
1405
                              cheese_window_countdown_picture_cb,
 
1406
                              cheese_window_countdown_hide_cb,
 
1407
                              (gpointer) cheese_window);
 
1408
      gtk_notebook_set_current_page (GTK_NOTEBOOK (cheese_window->fullscreen_bar), 1);
 
1409
 
 
1410
      /* show bar, start timeout
 
1411
       * ATTENTION: if the countdown is longer than FULLSCREEN_TIMEOUT,
 
1412
       * the bar will disapear before the countdown ends
 
1413
       */
 
1414
      cheese_window_fullscreen_show_bar (cheese_window);
 
1415
      cheese_window_fullscreen_set_timeout (cheese_window);
 
1416
    }
 
1417
    else
 
1418
    {
 
1419
      cheese_countdown_start ((CheeseCountdown *) cheese_window->countdown,
 
1420
                              cheese_window_countdown_picture_cb,
 
1421
                              cheese_window_countdown_hide_cb,
 
1422
                              (gpointer) cheese_window);
 
1423
      gtk_notebook_set_current_page (GTK_NOTEBOOK (cheese_window->notebook_bar), 1);
 
1424
    }
 
1425
  }
 
1426
  else
 
1427
  {
 
1428
    cheese_window_countdown_picture_cb (cheese_window);
 
1429
  }
 
1430
 
 
1431
  gtk_widget_set_sensitive (cheese_window->take_picture, FALSE);
 
1432
  gtk_widget_set_sensitive (cheese_window->take_picture_fullscreen, FALSE);
 
1433
 
 
1434
  if (cheese_window->webcam_mode == WEBCAM_MODE_BURST)
 
1435
  {
 
1436
    guint    repeat_delay = 1000;
 
1437
    gboolean countdown    = FALSE;
 
1438
 
 
1439
    g_object_get (cheese_window->gconf, "gconf_prop_burst_delay", &repeat_delay, NULL);
 
1440
    g_object_get (cheese_window->gconf, "gconf_prop_countdown", &countdown, NULL);
 
1441
 
 
1442
    if (countdown && repeat_delay < 5000)
 
1443
    {
 
1444
      /* A countdown takes 4 seconds, leave some headroom before repeating it.
 
1445
       * Magic number chosen via expiriment on Netbook */
 
1446
      repeat_delay = 5000;
 
1447
    }
 
1448
 
 
1449
    /* start burst mode phot series */
 
1450
    if (!cheese_window->is_bursting)
 
1451
    {
 
1452
      g_timeout_add (repeat_delay, cheese_window_take_photo, cheese_window);
 
1453
      cheese_window->is_bursting = TRUE;
 
1454
    }
 
1455
    cheese_window->repeat_count--;
 
1456
    if (cheese_window->repeat_count > 0)
 
1457
    {
 
1458
      return TRUE;
 
1459
    }
 
1460
  }
 
1461
  cheese_window->is_bursting = FALSE;
 
1462
 
 
1463
  return FALSE;
 
1464
}
 
1465
 
1292
1466
static void
1293
1467
cheese_window_action_button_clicked_cb (GtkWidget *widget, CheeseWindow *cheese_window)
1294
1468
{
1295
1469
  char *str;
1296
1470
 
1297
 
  if (cheese_window->webcam_mode == WEBCAM_MODE_PHOTO)
1298
 
  {
1299
 
    gboolean countdown;
1300
 
    g_object_get (cheese_window->gconf, "gconf_prop_countdown", &countdown, NULL);
1301
 
    if (countdown)
1302
 
    {
1303
 
      if (cheese_window->isFullscreen)
1304
 
      {
1305
 
        cheese_countdown_start ((CheeseCountdown *) cheese_window->countdown_fullscreen,
1306
 
                                cheese_window_countdown_picture_cb,
1307
 
                                cheese_window_countdown_hide_cb,
1308
 
                                (gpointer) cheese_window);
1309
 
        gtk_notebook_set_current_page (GTK_NOTEBOOK (cheese_window->fullscreen_bar), 1);
1310
 
 
1311
 
        /* show bar, start timeout
1312
 
         * ATTENTION: if the countdown is longer than FULLSCREEN_TIMEOUT,
1313
 
         * the bar will disapear before the countdown ends
1314
 
         */
1315
 
        cheese_window_fullscreen_show_bar (cheese_window);
1316
 
        cheese_window_fullscreen_set_timeout (cheese_window);
1317
 
      }
1318
 
      else
1319
 
      {
1320
 
        cheese_countdown_start ((CheeseCountdown *) cheese_window->countdown,
1321
 
                                cheese_window_countdown_picture_cb,
1322
 
                                cheese_window_countdown_hide_cb,
1323
 
                                (gpointer) cheese_window);
1324
 
        gtk_notebook_set_current_page (GTK_NOTEBOOK (cheese_window->notebook_bar), 1);
1325
 
      }
1326
 
    }
1327
 
    else
1328
 
    {
1329
 
      cheese_window_countdown_picture_cb (cheese_window);
1330
 
    }
1331
 
 
1332
 
    gtk_widget_set_sensitive (cheese_window->take_picture, FALSE);
1333
 
    gtk_widget_set_sensitive (cheese_window->take_picture_fullscreen, FALSE);
1334
 
 
1335
 
    /* FIXME: set menu inactive */
1336
 
  }
1337
 
  else if (cheese_window->webcam_mode == WEBCAM_MODE_VIDEO)
1338
 
  {
1339
 
    if (!cheese_window->recording)
1340
 
    {
 
1471
  switch (cheese_window->webcam_mode)
 
1472
  {
 
1473
    case WEBCAM_MODE_BURST:
 
1474
 
 
1475
      /* ignore keybindings and other while bursting */
 
1476
      if (cheese_window->is_bursting)
 
1477
      {
 
1478
        break;
 
1479
      }
1341
1480
      gtk_action_group_set_sensitive (cheese_window->actions_effects, FALSE);
1342
1481
      gtk_action_group_set_sensitive (cheese_window->actions_toggle, FALSE);
1343
 
      str = g_strconcat ("<b>", _("_Stop Recording"), "</b>", NULL);
1344
 
      gtk_label_set_text_with_mnemonic (GTK_LABEL (cheese_window->label_take_photo), str);
1345
 
      gtk_label_set_text_with_mnemonic (GTK_LABEL (cheese_window->label_take_photo_fullscreen), str);
1346
 
      g_free (str);
1347
 
      gtk_label_set_use_markup (GTK_LABEL (cheese_window->label_take_photo), TRUE);
1348
 
      gtk_image_set_from_stock (GTK_IMAGE (cheese_window->image_take_photo), GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_BUTTON);
1349
 
      gtk_label_set_use_markup (GTK_LABEL (cheese_window->label_take_photo_fullscreen), TRUE);
1350
 
      gtk_image_set_from_stock (GTK_IMAGE (cheese_window->image_take_photo_fullscreen),
1351
 
                                GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_BUTTON);
1352
 
 
1353
 
      cheese_window->video_filename = cheese_fileutil_get_new_media_filename (cheese_window->fileutil,
1354
 
                                                                              WEBCAM_MODE_VIDEO);
1355
 
      cheese_webcam_start_video_recording (cheese_window->webcam, cheese_window->video_filename);
1356
 
 
1357
 
      cheese_window->recording = TRUE;
1358
 
    }
1359
 
    else
1360
 
    {
1361
 
      cheese_window_stop_recording (cheese_window);
1362
 
    }
 
1482
      g_object_get (cheese_window->gconf, "gconf_prop_burst_repeat", &cheese_window->repeat_count, NULL); /* reset burst counter */
 
1483
    case WEBCAM_MODE_PHOTO:
 
1484
      cheese_window_take_photo (cheese_window);
 
1485
      break;
 
1486
    case WEBCAM_MODE_VIDEO:
 
1487
      if (!cheese_window->recording)
 
1488
      {
 
1489
        gtk_action_group_set_sensitive (cheese_window->actions_effects, FALSE);
 
1490
        gtk_action_group_set_sensitive (cheese_window->actions_toggle, FALSE);
 
1491
        str = g_strconcat ("<b>", _("_Stop Recording"), "</b>", NULL);
 
1492
        gtk_label_set_text_with_mnemonic (GTK_LABEL (cheese_window->label_take_photo), str);
 
1493
        gtk_label_set_text_with_mnemonic (GTK_LABEL (cheese_window->label_take_photo_fullscreen), str);
 
1494
        g_free (str);
 
1495
        gtk_label_set_use_markup (GTK_LABEL (cheese_window->label_take_photo), TRUE);
 
1496
        gtk_image_set_from_stock (GTK_IMAGE (
 
1497
                                    cheese_window->image_take_photo), GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_BUTTON);
 
1498
        gtk_label_set_use_markup (GTK_LABEL (cheese_window->label_take_photo_fullscreen), TRUE);
 
1499
        gtk_image_set_from_stock (GTK_IMAGE (cheese_window->image_take_photo_fullscreen),
 
1500
                                  GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_BUTTON);
 
1501
 
 
1502
        cheese_window->video_filename = cheese_fileutil_get_new_media_filename (cheese_window->fileutil,
 
1503
                                                                                WEBCAM_MODE_VIDEO);
 
1504
        cheese_webcam_start_video_recording (cheese_window->webcam, cheese_window->video_filename);
 
1505
 
 
1506
        cheese_window->recording = TRUE;
 
1507
      }
 
1508
      else
 
1509
      {
 
1510
        cheese_window_stop_recording (cheese_window);
 
1511
      }
 
1512
      break;
 
1513
    default:
 
1514
      g_assert_not_reached ();
 
1515
      break;
1363
1516
  }
1364
1517
}
1365
1518
 
1401
1554
  {"Fullscreen", GTK_STOCK_FULLSCREEN, NULL, "F11", NULL, G_CALLBACK (cheese_window_toggle_fullscreen), FALSE},
1402
1555
};
1403
1556
 
 
1557
static const GtkToggleActionEntry action_entries_wide_mode[] = {
 
1558
  {"WideMode", NULL, N_("_Wide mode"), NULL, NULL, G_CALLBACK (cheese_window_toggle_wide_mode), FALSE},
 
1559
};
 
1560
 
1404
1561
static const GtkRadioActionEntry action_entries_toggle[] = {
1405
1562
  {"Photo", NULL, N_("_Photo"), NULL, NULL, 0},
1406
1563
  {"Video", NULL, N_("_Video"), NULL, NULL, 1},
 
1564
  {"Burst", NULL, N_("_Burst"), NULL, NULL, 2},
1407
1565
};
1408
1566
 
1409
1567
static const GtkActionEntry action_entries_file[] = {
1418
1576
};
1419
1577
 
1420
1578
static const GtkActionEntry action_entries_photo[] = {
1421
 
  {"TakePhoto", NULL, N_("_Take a photo"), "space", NULL, G_CALLBACK (cheese_window_action_button_clicked_cb)},
 
1579
  {"TakePhoto", NULL, N_("_Take a Photo"), "space", NULL, G_CALLBACK (cheese_window_action_button_clicked_cb)},
1422
1580
};
1423
1581
 
1424
1582
static const GtkToggleActionEntry action_entries_video[] = {
1425
1583
  {"TakeVideo", NULL, N_("_Recording"), "space", NULL, G_CALLBACK (cheese_window_action_button_clicked_cb), FALSE},
1426
1584
};
1427
1585
 
 
1586
static const GtkActionEntry action_entries_burst[] = {
 
1587
  {"TakeBurst", NULL, N_("_Take multiple Photos"), "space", NULL, G_CALLBACK (cheese_window_action_button_clicked_cb)},
 
1588
};
 
1589
 
1428
1590
static const GtkActionEntry action_entries_account_photo[] = {
1429
1591
  {"SetAsAccountPhoto", NULL, N_("_Set As Account Photo"), NULL, NULL, G_CALLBACK (cheese_window_cmd_set_about_me_photo)},
1430
1592
};
1461
1623
    gtk_label_set_use_markup (GTK_LABEL (cheese_window->label_take_photo_fullscreen), TRUE);
1462
1624
    gtk_action_group_set_sensitive (cheese_window->actions_photo, TRUE);
1463
1625
    gtk_action_group_set_sensitive (cheese_window->actions_video, FALSE);
 
1626
    gtk_action_group_set_sensitive (cheese_window->actions_burst, FALSE);
 
1627
  }
 
1628
  else if (strcmp (gtk_action_get_name (GTK_ACTION (current)), "Burst") == 0)
 
1629
  {
 
1630
    cheese_window->webcam_mode = WEBCAM_MODE_BURST;
 
1631
 
 
1632
    str = g_strconcat ("<b>", _("_Take multiple Photos"), "</b>", NULL);
 
1633
    gtk_label_set_text_with_mnemonic (GTK_LABEL (cheese_window->label_take_photo), g_strdup (str));
 
1634
    gtk_label_set_use_markup (GTK_LABEL (cheese_window->label_take_photo), TRUE);
 
1635
    gtk_label_set_text_with_mnemonic (GTK_LABEL (cheese_window->label_take_photo_fullscreen), g_strdup (str));
 
1636
    gtk_label_set_use_markup (GTK_LABEL (cheese_window->label_take_photo_fullscreen), TRUE);
 
1637
    gtk_action_group_set_sensitive (cheese_window->actions_photo, FALSE);
 
1638
    gtk_action_group_set_sensitive (cheese_window->actions_video, FALSE);
 
1639
    gtk_action_group_set_sensitive (cheese_window->actions_burst, TRUE);
1464
1640
  }
1465
1641
  else
1466
1642
  {
1473
1649
    gtk_label_set_use_markup (GTK_LABEL (cheese_window->label_take_photo_fullscreen), TRUE);
1474
1650
    gtk_action_group_set_sensitive (cheese_window->actions_photo, FALSE);
1475
1651
    gtk_action_group_set_sensitive (cheese_window->actions_video, TRUE);
 
1652
    gtk_action_group_set_sensitive (cheese_window->actions_burst, FALSE);
1476
1653
  }
1477
1654
  g_free (str);
1478
1655
}
1525
1702
}
1526
1703
 
1527
1704
static void
1528
 
cheese_window_set_message_area (CheeseWindow *cheese_window,
1529
 
                                GtkWidget    *message_area)
 
1705
cheese_window_set_info_bar (CheeseWindow *cheese_window,
 
1706
                            GtkWidget    *info_bar)
1530
1707
{
1531
 
  if (cheese_window->message_area == message_area)
1532
 
    return;
1533
 
 
1534
 
  if (cheese_window->message_area != NULL)
1535
 
    gtk_widget_destroy (cheese_window->message_area);
1536
 
 
1537
 
  cheese_window->message_area = message_area;
1538
 
 
1539
 
  if (message_area == NULL)
1540
 
    return;
1541
 
 
1542
 
  gtk_container_add (GTK_CONTAINER (cheese_window->message_area_frame), cheese_window->message_area);
1543
 
  gtk_widget_show (GTK_WIDGET (cheese_window->message_area));
 
1708
  if (cheese_window->info_bar == info_bar)
 
1709
    return;
 
1710
 
 
1711
  if (cheese_window->info_bar != NULL)
 
1712
    gtk_widget_destroy (cheese_window->info_bar);
 
1713
 
 
1714
  cheese_window->info_bar = info_bar;
 
1715
 
 
1716
  if (info_bar == NULL)
 
1717
    return;
 
1718
 
 
1719
  gtk_container_add (GTK_CONTAINER (cheese_window->info_bar_frame), cheese_window->info_bar);
 
1720
  gtk_widget_show (GTK_WIDGET (cheese_window->info_bar));
1544
1721
}
1545
1722
 
1546
1723
static void
1549
1726
  GError     *error = NULL;
1550
1727
  char       *path;
1551
1728
  GtkBuilder *builder;
1552
 
 
1553
 
#ifdef HILDON
1554
 
  HildonProgram *program = hildon_program_get_instance ();
1555
 
  GtkWidget     *menu;
1556
 
  GtkWidget     *menuitem;
1557
 
#else
1558
 
  GtkWidget *menubar;
1559
 
#endif
1560
 
 
1561
 
 
1562
 
  cheese_window->message_area = NULL;
 
1729
  GtkWidget  *menubar;
 
1730
 
 
1731
  cheese_window->info_bar = NULL;
1563
1732
 
1564
1733
  builder = gtk_builder_new ();
1565
1734
  gtk_builder_add_from_file (builder, PACKAGE_DATADIR "/cheese.ui", &error);
1574
1743
  cheese_window->button_effects              = GTK_WIDGET (gtk_builder_get_object (builder, "button_effects"));
1575
1744
  cheese_window->button_photo                = GTK_WIDGET (gtk_builder_get_object (builder, "button_photo"));
1576
1745
  cheese_window->button_video                = GTK_WIDGET (gtk_builder_get_object (builder, "button_video"));
 
1746
  cheese_window->button_burst                = GTK_WIDGET (gtk_builder_get_object (builder, "button_burst"));
1577
1747
  cheese_window->image_take_photo            = GTK_WIDGET (gtk_builder_get_object (builder, "image_take_photo"));
1578
1748
  cheese_window->label_effects               = GTK_WIDGET (gtk_builder_get_object (builder, "label_effects"));
1579
1749
  cheese_window->label_photo                 = GTK_WIDGET (gtk_builder_get_object (builder, "label_photo"));
1580
1750
  cheese_window->label_take_photo            = GTK_WIDGET (gtk_builder_get_object (builder, "label_take_photo"));
1581
1751
  cheese_window->label_video                 = GTK_WIDGET (gtk_builder_get_object (builder, "label_video"));
1582
1752
  cheese_window->main_vbox                   = GTK_WIDGET (gtk_builder_get_object (builder, "main_vbox"));
 
1753
  cheese_window->netbook_alignment           = GTK_WIDGET (gtk_builder_get_object (builder, "netbook_alignment"));
 
1754
  cheese_window->togglegroup_alignment       = GTK_WIDGET (gtk_builder_get_object (builder, "togglegroup_alignment"));
 
1755
  cheese_window->effect_button_alignment     = GTK_WIDGET (gtk_builder_get_object (builder, "effect_button_alignment"));
 
1756
  cheese_window->toolbar_alignment           = GTK_WIDGET (gtk_builder_get_object (builder, "toolbar_alignment"));
1583
1757
  cheese_window->video_vbox                  = GTK_WIDGET (gtk_builder_get_object (builder, "video_vbox"));
1584
1758
  cheese_window->notebook                    = GTK_WIDGET (gtk_builder_get_object (builder, "notebook"));
1585
1759
  cheese_window->notebook_bar                = GTK_WIDGET (gtk_builder_get_object (builder, "notebook_bar"));
1590
1764
  cheese_window->countdown_frame             = GTK_WIDGET (gtk_builder_get_object (builder, "countdown_frame"));
1591
1765
  cheese_window->effect_frame                = GTK_WIDGET (gtk_builder_get_object (builder, "effect_frame"));
1592
1766
  cheese_window->effect_alignment            = GTK_WIDGET (gtk_builder_get_object (builder, "effect_alignment"));
1593
 
  cheese_window->message_area_frame          = GTK_WIDGET (gtk_builder_get_object (builder, "message_area_frame"));
 
1767
  cheese_window->info_bar_frame              = GTK_WIDGET (gtk_builder_get_object (builder, "info_bar_frame"));
1594
1768
  cheese_window->fullscreen_popup            = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_popup"));
1595
1769
  cheese_window->fullscreen_bar              = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_notebook_bar"));
1596
1770
  cheese_window->button_effects_fullscreen   = GTK_WIDGET (gtk_builder_get_object (builder, "button_effects_fullscreen"));
1597
1771
  cheese_window->button_photo_fullscreen     = GTK_WIDGET (gtk_builder_get_object (builder, "button_photo_fullscreen"));
1598
1772
  cheese_window->button_video_fullscreen     = GTK_WIDGET (gtk_builder_get_object (builder, "button_video_fullscreen"));
 
1773
  cheese_window->button_burst_fullscreen     = GTK_WIDGET (gtk_builder_get_object (builder, "button_burst_fullscreen"));
1599
1774
  cheese_window->take_picture_fullscreen     = GTK_WIDGET (gtk_builder_get_object (builder, "take_picture_fullscreen"));
1600
1775
  cheese_window->label_take_photo_fullscreen =
1601
1776
    GTK_WIDGET (gtk_builder_get_object (builder, "label_take_photo_fullscreen"));
1607
1782
    GTK_WIDGET (gtk_builder_get_object (builder, "countdown_frame_fullscreen"));
1608
1783
  cheese_window->button_exit_fullscreen = GTK_WIDGET (gtk_builder_get_object (builder, "button_exit_fullscreen"));
1609
1784
 
 
1785
  g_object_unref (builder);
 
1786
 
1610
1787
  /* configure the popup position and size */
1611
1788
  GdkScreen *screen = gtk_window_get_screen (GTK_WINDOW (cheese_window->fullscreen_popup));
1612
1789
  gtk_window_set_default_size (GTK_WINDOW (cheese_window->fullscreen_popup),
1623
1800
                    G_CALLBACK (cheese_window_exit_fullscreen_button_clicked_cb),
1624
1801
                    cheese_window);
1625
1802
 
1626
 
#ifdef HILDON
1627
 
  /* Reparent widgets in case we use hildon. This saves us maintaining two
1628
 
   * GtkBuilder ui files
1629
 
   */
1630
 
  cheese_window->window    = hildon_window_new ();
1631
 
  cheese_window->main_hbox = gtk_hbox_new (FALSE, 0);
1632
 
  hildon_program_add_window (program, HILDON_WINDOW (cheese_window->window));
1633
 
  gtk_container_add (GTK_CONTAINER (cheese_window->window), cheese_window->main_hbox);
1634
 
  g_object_ref (cheese_window->thumb_scrollwindow);
1635
 
  g_object_ref (cheese_window->video_vbox);
1636
 
  gtk_container_remove (GTK_CONTAINER (cheese_window->video_vbox), cheese_window->thumb_scrollwindow);
1637
 
  gtk_container_remove (GTK_CONTAINER (cheese_window->main_vbox), cheese_window->video_vbox);
1638
 
  gtk_box_pack_start (GTK_BOX (cheese_window->main_hbox), cheese_window->video_vbox, TRUE, TRUE, 0);
1639
 
  gtk_box_pack_start (GTK_BOX (cheese_window->main_hbox), GTK_WIDGET (cheese_window->thumb_scrollwindow),
1640
 
                      FALSE, FALSE, 0);
1641
 
  gtk_widget_destroy (cheese_window->main_vbox);
1642
 
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (cheese_window->thumb_scrollwindow),
1643
 
                                  GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1644
 
  g_object_unref (cheese_window->thumb_scrollwindow);
1645
 
  g_object_unref (cheese_window->video_vbox);
1646
 
#endif
1647
 
 
1648
 
  g_object_unref (builder);
1649
 
 
1650
1803
  char *str = g_strconcat ("<b>", _("_Take a photo"), "</b>", NULL);
1651
1804
  gtk_label_set_text_with_mnemonic (GTK_LABEL (cheese_window->label_take_photo), str);
1652
1805
  gtk_label_set_text_with_mnemonic (GTK_LABEL (cheese_window->label_take_photo_fullscreen), str);
1657
1810
  gtk_widget_set_sensitive (GTK_WIDGET (cheese_window->take_picture_fullscreen), FALSE);
1658
1811
 
1659
1812
  cheese_window->thumb_view = cheese_thumb_view_new ();
1660
 
  cheese_window->thumb_nav  = eog_thumb_nav_new (cheese_window->thumb_view, TRUE);
 
1813
  cheese_window->thumb_nav  = eog_thumb_nav_new (cheese_window->thumb_view, FALSE);
 
1814
 
1661
1815
  gtk_container_add (GTK_CONTAINER (cheese_window->thumb_scrollwindow), cheese_window->thumb_nav);
1662
1816
 
 
1817
  /* show the scroll window to get it included in the size requisition done later */
 
1818
  gtk_widget_show_all (cheese_window->thumb_scrollwindow);
 
1819
 
1663
1820
  char *gconf_effects;
1664
1821
  g_object_get (cheese_window->gconf, "gconf_prop_selected_effects", &gconf_effects, NULL);
1665
1822
  cheese_window->effect_chooser = cheese_effect_chooser_new (gconf_effects);
1678
1835
  cheese_window->countdown_fullscreen = cheese_countdown_new ();
1679
1836
  gtk_container_add (GTK_CONTAINER (cheese_window->countdown_frame_fullscreen), cheese_window->countdown_fullscreen);
1680
1837
 
 
1838
  gtk_widget_realize (cheese_window->screen);
 
1839
  GdkWindow *win = gtk_widget_get_window (cheese_window->screen);
 
1840
  if (!gdk_window_ensure_native (win))
 
1841
  {
 
1842
    /* FIXME: this breaks offscreen stuff, we should really find
 
1843
     * another way to embed video that doesn't require an XID */
 
1844
 
 
1845
    /* abort: no native window, no xoverlay, no cheese. */
 
1846
    g_error ("Could not create a native X11 window for the drawing area");
 
1847
  }
 
1848
  gdk_window_set_back_pixmap (gtk_widget_get_window (cheese_window->screen), NULL, FALSE);
 
1849
  gtk_widget_set_app_paintable (cheese_window->screen, TRUE);
 
1850
  gtk_widget_set_double_buffered (cheese_window->screen, FALSE);
1681
1851
  gtk_widget_add_events (cheese_window->screen, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
1682
1852
 
1683
1853
  cheese_window->ui_manager = gtk_ui_manager_new ();
1700
1870
                                                                             action_entries_fullscreen,
1701
1871
                                                                             G_N_ELEMENTS (action_entries_fullscreen));
1702
1872
 
 
1873
  cheese_window->actions_wide_mode = cheese_window_toggle_action_group_new (cheese_window,
 
1874
                                                                            "ActionsWideMode",
 
1875
                                                                            action_entries_wide_mode,
 
1876
                                                                            G_N_ELEMENTS (action_entries_fullscreen));
 
1877
 
1703
1878
  cheese_window->actions_preferences = cheese_window_action_group_new (cheese_window,
1704
1879
                                                                       "ActionsPreferences",
1705
1880
                                                                       action_entries_preferences,
1721
1896
                                                                        action_entries_video,
1722
1897
                                                                        G_N_ELEMENTS (action_entries_video));
1723
1898
  gtk_action_group_set_sensitive (cheese_window->actions_video, FALSE);
 
1899
  cheese_window->actions_burst = cheese_window_action_group_new (cheese_window,
 
1900
                                                                 "ActionsBurst",
 
1901
                                                                 action_entries_burst,
 
1902
                                                                 G_N_ELEMENTS (action_entries_burst));
 
1903
  gtk_action_group_set_sensitive (cheese_window->actions_burst, FALSE);
1724
1904
  cheese_window->actions_account_photo = cheese_window_action_group_new (cheese_window,
1725
1905
                                                                         "ActionsAccountPhoto",
1726
1906
                                                                         action_entries_account_photo,
1788
1968
  g_object_get (cheese_window->gconf, "gconf_prop_enable_delete", &enable_delete, NULL);
1789
1969
  gtk_action_set_visible (GTK_ACTION (action), enable_delete);
1790
1970
 
1791
 
#ifdef HILDON
1792
 
  menu     = gtk_menu_new ();
1793
 
  menuitem = gtk_menu_item_new_with_label (_("Quit"));
1794
 
  g_signal_connect (menuitem, "activate",
1795
 
                    G_CALLBACK (cheese_window_cmd_close),
1796
 
                    cheese_window);
1797
 
  gtk_menu_shell_append (menu, menuitem);
1798
 
 
1799
 
  menuitem = gtk_menu_item_new_with_label (_("About"));
1800
 
  g_signal_connect (menuitem, "activate",
1801
 
                    G_CALLBACK (cheese_window_cmd_about),
1802
 
                    cheese_window);
1803
 
  gtk_menu_shell_append (menu, menuitem);
1804
 
 
1805
 
  hildon_window_set_menu (HILDON_WINDOW (cheese_window->window), GTK_MENU (menu));
1806
 
#else
1807
1971
  menubar = gtk_ui_manager_get_widget (cheese_window->ui_manager, "/MainMenu");
1808
1972
  gtk_box_pack_start (GTK_BOX (cheese_window->main_vbox), menubar, FALSE, FALSE, 0);
1809
 
#endif
1810
1973
 
1811
1974
  cheese_window->thumb_view_popup_menu = gtk_ui_manager_get_widget (cheese_window->ui_manager,
1812
1975
                                                                    "/ThumbnailPopup");
1821
1984
  gtk_action_group_set_sensitive (cheese_window->actions_file, FALSE);
1822
1985
 
1823
1986
  action = gtk_ui_manager_get_action (cheese_window->ui_manager, "/MainMenu/Edit/Effects");
1824
 
  gtk_action_connect_proxy (GTK_ACTION (action), GTK_WIDGET (cheese_window->button_effects));
1825
 
  gtk_action_connect_proxy (GTK_ACTION (action), GTK_WIDGET (cheese_window->button_effects_fullscreen));
 
1987
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (cheese_window->button_effects), action);
 
1988
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (cheese_window->button_effects_fullscreen), action);
1826
1989
 
1827
1990
  action = gtk_ui_manager_get_action (cheese_window->ui_manager, "/MainMenu/Cheese/Photo");
1828
 
  gtk_action_connect_proxy (GTK_ACTION (action), GTK_WIDGET (cheese_window->button_photo));
1829
 
  gtk_action_connect_proxy (GTK_ACTION (action), GTK_WIDGET (cheese_window->button_photo_fullscreen));
 
1991
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (cheese_window->button_photo), action);
 
1992
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (cheese_window->button_photo_fullscreen), action);
1830
1993
 
1831
1994
  action = gtk_ui_manager_get_action (cheese_window->ui_manager, "/MainMenu/Cheese/Video");
1832
 
  gtk_action_connect_proxy (GTK_ACTION (action), GTK_WIDGET (cheese_window->button_video));
1833
 
  gtk_action_connect_proxy (GTK_ACTION (action), GTK_WIDGET (cheese_window->button_video_fullscreen));
 
1995
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (cheese_window->button_video), action);
 
1996
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (cheese_window->button_video_fullscreen), action);
 
1997
 
 
1998
  action = gtk_ui_manager_get_action (cheese_window->ui_manager, "/MainMenu/Cheese/Burst");
 
1999
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (cheese_window->button_burst), action);
 
2000
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (cheese_window->button_burst_fullscreen), action);
1834
2001
 
1835
2002
 
1836
2003
  /* Default handlers for closing the application */
1839
2006
  g_signal_connect (cheese_window->window, "delete_event",
1840
2007
                    G_CALLBACK (cheese_window_delete_event_cb), NULL);
1841
2008
 
 
2009
  /* Listen for key presses */
 
2010
  gtk_widget_add_events (cheese_window->window, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
 
2011
  g_signal_connect (cheese_window->window, "key_press_event",
 
2012
                    G_CALLBACK (cheese_window_key_press_event_cb), cheese_window);
 
2013
 
1842
2014
  g_signal_connect (cheese_window->take_picture, "clicked",
1843
2015
                    G_CALLBACK (cheese_window_action_button_clicked_cb), cheese_window);
1844
2016
  g_signal_connect (cheese_window->take_picture_fullscreen, "clicked",
1855
2027
  char      *webcam_device = NULL;
1856
2028
  int        x_resolution;
1857
2029
  int        y_resolution;
1858
 
  GtkWidget *message_area;
 
2030
  gdouble    brightness;
 
2031
  gdouble    contrast;
 
2032
  gdouble    saturation;
 
2033
  gdouble    hue;
 
2034
  GtkWidget *info_bar;
1859
2035
 
1860
2036
  GError *error;
1861
2037
 
1862
 
  g_object_get (cheese_window->gconf, "gconf_prop_x_resolution", &x_resolution,
1863
 
                "gconf_prop_y_resolution", &y_resolution, "gconf_prop_webcam", &webcam_device, NULL);
 
2038
  g_object_get (cheese_window->gconf,
 
2039
                "gconf_prop_x_resolution", &x_resolution,
 
2040
                "gconf_prop_y_resolution", &y_resolution,
 
2041
                "gconf_prop_webcam", &webcam_device,
 
2042
                "gconf_prop_brightness", &brightness,
 
2043
                "gconf_prop_contrast", &contrast,
 
2044
                "gconf_prop_saturation", &saturation,
 
2045
                "gconf_prop_hue", &hue,
 
2046
                NULL);
1864
2047
 
1865
2048
  gdk_threads_enter ();
1866
2049
  cheese_window->webcam = cheese_webcam_new (cheese_window->screen,
1911
2094
  cheese_webcam_set_effect (cheese_window->webcam,
1912
2095
                            cheese_effect_chooser_get_selection (CHEESE_EFFECT_CHOOSER (cheese_window->effect_chooser)));
1913
2096
 
 
2097
  cheese_webcam_set_balance_property (cheese_window->webcam, "brightness", brightness);
 
2098
  cheese_webcam_set_balance_property (cheese_window->webcam, "contrast", contrast);
 
2099
  cheese_webcam_set_balance_property (cheese_window->webcam, "saturation", saturation);
 
2100
  cheese_webcam_set_balance_property (cheese_window->webcam, "hue", hue);
 
2101
 
1914
2102
  cheese_webcam_play (cheese_window->webcam);
1915
2103
  gdk_threads_enter ();
1916
2104
  gtk_notebook_set_current_page (GTK_NOTEBOOK (cheese_window->notebook), 0);
1917
2105
  ephy_spinner_stop (EPHY_SPINNER (cheese_window->throbber));
1918
2106
  if (cheese_webcam_get_num_webcam_devices (cheese_window->webcam) == 0)
1919
2107
  {
1920
 
    message_area = cheese_no_camera_message_area ();
 
2108
    info_bar = cheese_no_camera_info_bar_new ();
1921
2109
 
1922
 
    g_signal_connect (message_area,
 
2110
    g_signal_connect (info_bar,
1923
2111
                      "response",
1924
 
                      G_CALLBACK (cheese_window_no_camera_message_area_response),
 
2112
                      G_CALLBACK (cheese_window_no_camera_info_bar_response),
1925
2113
                      cheese_window);
1926
2114
 
1927
 
    cheese_window_set_message_area (cheese_window, message_area);
 
2115
    cheese_window_set_info_bar (cheese_window, info_bar);
1928
2116
  }
1929
2117
  gtk_widget_set_sensitive (GTK_WIDGET (cheese_window->take_picture), TRUE);
1930
2118
  gtk_widget_set_sensitive (GTK_WIDGET (cheese_window->take_picture_fullscreen), TRUE);
1931
2119
  gtk_action_group_set_sensitive (cheese_window->actions_effects, TRUE);
 
2120
 
1932
2121
  gdk_threads_leave ();
1933
2122
}
1934
2123
 
1935
2124
void
1936
 
cheese_window_init (char *hal_dev_udi, CheeseDbus *dbus_server)
 
2125
cheese_window_init (char *hal_dev_udi, CheeseDbus *dbus_server, gboolean startup_in_wide_mode)
1937
2126
{
1938
2127
  CheeseWindow *cheese_window;
 
2128
  gboolean      startup_in_wide_mode_saved;
1939
2129
 
1940
2130
  cheese_window = g_new0 (CheeseWindow, 1);
1941
2131
 
1945
2135
  cheese_window->flash               = cheese_flash_new ();
1946
2136
  cheese_window->audio_play_counter  = 0;
1947
2137
  cheese_window->isFullscreen        = FALSE;
 
2138
  cheese_window->is_bursting         = FALSE;
1948
2139
 
1949
2140
  cheese_window->server = dbus_server;
1950
2141
 
1956
2147
  cheese_window_create_window (cheese_window);
1957
2148
  gtk_action_group_set_sensitive (cheese_window->actions_effects, FALSE);
1958
2149
 
1959
 
  gtk_widget_show_all (cheese_window->window);
1960
2150
  ephy_spinner_start (EPHY_SPINNER (cheese_window->throbber));
1961
2151
 
1962
2152
  gtk_notebook_set_current_page (GTK_NOTEBOOK (cheese_window->notebook), 2);
1964
2154
  cheese_window->webcam_mode = WEBCAM_MODE_PHOTO;
1965
2155
  cheese_window->recording   = FALSE;
1966
2156
 
 
2157
  g_object_get (cheese_window->gconf,
 
2158
                "gconf_prop_wide_mode",
 
2159
                &startup_in_wide_mode_saved,
 
2160
                NULL);
 
2161
 
 
2162
  startup_in_wide_mode = startup_in_wide_mode_saved ? TRUE : startup_in_wide_mode;
 
2163
 
 
2164
  if (startup_in_wide_mode)
 
2165
  {
 
2166
    GtkAction *action = gtk_ui_manager_get_action (cheese_window->ui_manager, "/MainMenu/Cheese/WideMode");
 
2167
    gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
 
2168
  }
 
2169
 
 
2170
  /* handy trick to set default size of the drawing area while not
 
2171
   * limiting its minimum size, thanks Owen! */
 
2172
 
 
2173
  GtkRequisition req;
 
2174
  gtk_widget_set_size_request (cheese_window->notebook,
 
2175
                               DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT);
 
2176
  gtk_widget_size_request (cheese_window->window, &req);
 
2177
  gtk_window_resize (GTK_WINDOW (cheese_window->window), req.width, req.height);
 
2178
  gtk_widget_set_size_request (cheese_window->notebook, -1, -1);
 
2179
 
 
2180
  gtk_widget_show_all (cheese_window->window);
 
2181
 
1967
2182
  /* Run cam setup in its own thread */
1968
2183
  GError *error = NULL;
1969
2184
  if (!g_thread_create ((GThreadFunc) setup_camera, cheese_window, FALSE, &error))
1972
2187
    g_error_free (error);
1973
2188
    return;
1974
2189
  }
1975
 
 
1976
 
  /* Make URLs and email clickable in about dialog */
1977
 
  gtk_about_dialog_set_url_hook (cheese_about_dialog_handle_url, NULL, NULL);
1978
 
  gtk_about_dialog_set_email_hook (cheese_about_dialog_handle_email, NULL, NULL);
1979
2190
}