← Back to branch summary

~ubuntu-branches/debian/stretch/cheese/stretch

« back to all changes in this revision

Viewing changes to src/cheese-prefs-dialog.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Biebl
  • Date: 2010-05-04 17:37:18 UTC
  • mfrom: (1.1.13 upstream)
  • Revision ID: james.westby@ubuntu.com-20100504173718-k2rx3nryi4vd0xyx
Tags: 2.30.1-1
http://bugs.debian.org/573774
* New upstream release.
  - HAL dependency has been dropped. Use (g)udev for v4l capability probing
    on Linux. Closes: #573774
  - Split code into separate libraries.
* debian/control.in
  - Drop Build-Depends on libhal-dev.
  - Drop Build-Depends on libebook1.2-dev.
  - Bump Build-Depends on libgtk2.0-dev to (>= 2.19.1).
  - Bump Build-Depends on libgstreamer*-dev to (>= 0.10.23).
  - Add Build-Depends on libcanberra-gtk-dev.
  - Add Build-Depends on libxtst-dev.
  - Add Build-Depends on libgudev-1.0-dev on Linux.
  - Bump Standards-Version to 3.8.4. No further changes.
* Switch to source format 3.0 (quilt)
  - Add debian/source/format.
* debian/rules
  - Drop lpia specific configure flags, lpia is dead.
* Update package layout (based on work by Ubuntu)
  - Move data files into new cheese-common package.
  - Keep binary along with its desktop and dbus service file in the cheese
    package.
  - Add libcheese-gtk18 and libcheese-gtk-dev package for the new
    libcheese-gtk library. Use a symbols file for improved shlibs
    dependencies.
  - Add Conflicts/Replaces to cheese-common to ensure proper upgrades from
    previous versions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cheese-prefs-dialog.c
24
24
{
25
25
  GtkWidget *cheese_prefs_dialog;
26
26
  GtkWidget *resolution_combo_box;
27
 
  GtkWidget *webcam_combo_box;
 
27
  GtkWidget *camera_combo_box;
28
28
  GtkWidget *brightness_scale;
29
29
  GtkWidget *contrast_scale;
30
30
  GtkWidget *saturation_scale;
33
33
  GtkWidget *burst_delay;
34
34
 
35
35
  GtkWidget *parent;
36
 
  CheeseWebcam *webcam;
 
36
  CheeseCamera *camera;
37
37
 
38
38
  CheesePrefsDialogWidgets *widgets;
39
39
} CheesePrefsDialog;
58
58
                                                                          "cheese_prefs_dialog"));
59
59
  prefs_dialog->resolution_combo_box = GTK_WIDGET (gtk_builder_get_object (builder,
60
60
                                                                           "resolution_combo_box"));
61
 
  prefs_dialog->webcam_combo_box = GTK_WIDGET (gtk_builder_get_object (builder,
62
 
                                                                       "webcam_combo_box"));
 
61
  prefs_dialog->camera_combo_box = GTK_WIDGET (gtk_builder_get_object (builder,
 
62
                                                                       "camera_combo_box"));
63
63
  prefs_dialog->brightness_scale = GTK_WIDGET (gtk_builder_get_object (builder,
64
64
                                                                       "brightness_scale"));
65
65
  prefs_dialog->contrast_scale = GTK_WIDGET (gtk_builder_get_object (builder,
79
79
static void
80
80
cheese_prefs_dialog_on_resolution_changed (CheesePrefsWidget *widget, gpointer user_data)
81
81
{
82
 
  CheeseWebcam      *webcam;
83
 
  CheeseVideoFormat *current_format;
 
82
  CheeseCamera      *camera;
84
83
  CheeseVideoFormat *new_format;
85
84
 
86
 
  g_object_get (widget, "webcam", &webcam, NULL);
87
 
 
88
 
  current_format = cheese_webcam_get_current_video_format (webcam);
89
 
  new_format     = cheese_prefs_resolution_combo_get_selected_format (CHEESE_PREFS_RESOLUTION_COMBO (widget));
90
 
 
91
 
  if (new_format != current_format)
92
 
    cheese_webcam_set_video_format (webcam, new_format);
 
85
  g_object_get (widget, "camera", &camera, NULL);
 
86
 
 
87
  new_format = cheese_prefs_resolution_combo_get_selected_format (CHEESE_PREFS_RESOLUTION_COMBO (widget));
 
88
  cheese_camera_set_video_format (camera, new_format);
93
89
}
94
90
 
95
91
static void
96
92
cheese_prefs_dialog_on_device_changed (CheesePrefsWidget *widget, CheesePrefsDialog *prefs_dialog)
97
93
{
98
 
  CheeseWebcam *webcam;
 
94
  CheeseCamera *camera;
99
95
  char         *new_device_name;
100
96
  char         *old_device_name;
101
97
 
102
 
  g_object_get (widget, "webcam", &webcam, NULL);
103
 
  g_object_get (webcam, "device_name", &old_device_name, NULL);
 
98
  g_object_get (widget, "camera", &camera, NULL);
 
99
  g_object_get (camera, "device_name", &old_device_name, NULL);
104
100
 
105
 
  new_device_name = cheese_prefs_webcam_combo_get_selected_webcam (CHEESE_PREFS_WEBCAM_COMBO (widget));
106
 
  g_object_set (webcam, "device_name", new_device_name, NULL);
 
101
  new_device_name = cheese_prefs_camera_combo_get_selected_camera (CHEESE_PREFS_CAMERA_COMBO (widget));
 
102
  g_object_set (camera, "device_name", new_device_name, NULL);
107
103
  g_free (new_device_name);
108
 
  if (!cheese_webcam_switch_webcam_device (webcam))
 
104
  if (!cheese_camera_switch_camera_device (camera))
109
105
  {
110
 
    g_warning ("Couldn't change webcam device.");
 
106
    g_warning ("Couldn't change camera device.");
111
107
 
112
108
    /* Revert to default device */
113
 
    g_object_set (webcam, "device_name", old_device_name, NULL);
 
109
    g_object_set (camera, "device_name", old_device_name, NULL);
114
110
  }
115
111
  cheese_prefs_dialog_widgets_synchronize (prefs_dialog->widgets);
116
112
  g_free (old_device_name);
120
116
cheese_prefs_dialog_setup_widgets (CheesePrefsDialog *prefs_dialog)
121
117
{
122
118
  CheesePrefsWidget *resolution_widget;
123
 
  CheesePrefsWidget *webcam_widget;
 
119
  CheesePrefsWidget *camera_widget;
124
120
  CheesePrefsWidget *brightness_widget;
125
121
  CheesePrefsWidget *contrast_widget;
126
122
  CheesePrefsWidget *saturation_widget;
129
125
  CheesePrefsWidget *burst_repeat_widget;
130
126
 
131
127
  resolution_widget = CHEESE_PREFS_WIDGET (cheese_prefs_resolution_combo_new (prefs_dialog->resolution_combo_box,
132
 
                                                                              prefs_dialog->webcam,
 
128
                                                                              prefs_dialog->camera,
133
129
                                                                              "gconf_prop_x_resolution",
134
130
                                                                              "gconf_prop_y_resolution",
135
131
                                                                              0, 0));
138
134
                    NULL);
139
135
  cheese_prefs_dialog_widgets_add (prefs_dialog->widgets, resolution_widget);
140
136
 
141
 
  webcam_widget = CHEESE_PREFS_WIDGET (cheese_prefs_webcam_combo_new (prefs_dialog->webcam_combo_box,
142
 
                                                                      prefs_dialog->webcam,
143
 
                                                                      "gconf_prop_webcam"));
 
137
  camera_widget = CHEESE_PREFS_WIDGET (cheese_prefs_camera_combo_new (prefs_dialog->camera_combo_box,
 
138
                                                                      prefs_dialog->camera,
 
139
                                                                      "gconf_prop_camera"));
144
140
 
145
 
  g_signal_connect (G_OBJECT (webcam_widget), "changed",
 
141
  g_signal_connect (G_OBJECT (camera_widget), "changed",
146
142
                    G_CALLBACK (cheese_prefs_dialog_on_device_changed),
147
143
                    prefs_dialog);
148
 
  cheese_prefs_dialog_widgets_add (prefs_dialog->widgets, webcam_widget);
 
144
  cheese_prefs_dialog_widgets_add (prefs_dialog->widgets, camera_widget);
149
145
 
150
146
  brightness_widget = CHEESE_PREFS_WIDGET (cheese_prefs_balance_scale_new (prefs_dialog->brightness_scale,
151
 
                                                                           prefs_dialog->webcam, "brightness",
 
147
                                                                           prefs_dialog->camera, "brightness",
152
148
                                                                           "gconf_prop_brightness"));
153
149
 
154
150
  cheese_prefs_dialog_widgets_add (prefs_dialog->widgets, brightness_widget);
155
151
 
156
152
  contrast_widget = CHEESE_PREFS_WIDGET (cheese_prefs_balance_scale_new (prefs_dialog->contrast_scale,
157
 
                                                                         prefs_dialog->webcam, "contrast",
 
153
                                                                         prefs_dialog->camera, "contrast",
158
154
                                                                         "gconf_prop_contrast"));
159
155
 
160
156
  cheese_prefs_dialog_widgets_add (prefs_dialog->widgets, contrast_widget);
161
157
 
162
158
  saturation_widget = CHEESE_PREFS_WIDGET (cheese_prefs_balance_scale_new (prefs_dialog->saturation_scale,
163
 
                                                                           prefs_dialog->webcam, "saturation",
 
159
                                                                           prefs_dialog->camera, "saturation",
164
160
                                                                           "gconf_prop_saturation"));
165
161
 
166
162
  cheese_prefs_dialog_widgets_add (prefs_dialog->widgets, saturation_widget);
167
163
 
168
164
  hue_widget = CHEESE_PREFS_WIDGET (cheese_prefs_balance_scale_new (prefs_dialog->hue_scale,
169
 
                                                                    prefs_dialog->webcam, "hue",
 
165
                                                                    prefs_dialog->camera, "hue",
170
166
                                                                    "gconf_prop_hue"));
171
167
 
172
168
  cheese_prefs_dialog_widgets_add (prefs_dialog->widgets, hue_widget);
195
191
  g_free (prefs_dialog);
196
192
}
197
193
 
 
194
static void
 
195
cheese_prefs_dialog_response (GtkDialog         *dialog,
 
196
                              int                response_id,
 
197
                              CheesePrefsDialog *prefs_dialog)
 
198
{
 
199
  cheese_prefs_dialog_destroy_dialog (prefs_dialog);
 
200
}
 
201
 
198
202
void
199
 
cheese_prefs_dialog_run (GtkWidget *parent, CheeseGConf *gconf, CheeseWebcam *webcam)
 
203
cheese_prefs_dialog_run (GtkWidget *parent, CheeseGConf *gconf, CheeseCamera *camera)
200
204
{
201
205
  CheesePrefsDialog *prefs_dialog;
202
206
 
203
207
  prefs_dialog = g_new0 (CheesePrefsDialog, 1);
204
208
 
205
209
  prefs_dialog->parent  = parent;
206
 
  prefs_dialog->webcam  = webcam;
 
210
  prefs_dialog->camera  = camera;
207
211
  prefs_dialog->widgets = cheese_prefs_dialog_widgets_new (gconf);
208
212
 
209
213
  cheese_prefs_dialog_create_dialog (prefs_dialog);
210
214
  cheese_prefs_dialog_setup_widgets (prefs_dialog);
211
215
 
212
 
  gtk_dialog_run (GTK_DIALOG (prefs_dialog->cheese_prefs_dialog));
213
 
 
214
 
  cheese_prefs_dialog_destroy_dialog (prefs_dialog);
 
216
  gtk_widget_show (prefs_dialog->cheese_prefs_dialog);
 
217
  g_signal_connect (G_OBJECT (prefs_dialog->cheese_prefs_dialog), "response",
 
218
                    G_CALLBACK (cheese_prefs_dialog_response), prefs_dialog);
215
219
}