1 /*
2  *  Entangle: Tethered Camera Control & Capture
3  *
4  *  Copyright (C) 2009-2017 Daniel P. Berrange
5  *
6  *  This program is free software: you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation, either version 3 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  *
19  */
20 
21 #include <string.h>
22 #include <unistd.h>
23 #include <gtk/gtk.h>
24 #include <glib/gi18n.h>
25 
26 #include "entangle-debug.h"
27 #include "entangle-camera-support.h"
28 
29 
30 gboolean do_support_close(GtkButton *src,
31                           gpointer data);
32 gboolean do_support_delete(GtkWidget *src,
33                            GdkEvent *ev);
34 
35 typedef struct _EntangleCameraSupportPrivate EntangleCameraSupportPrivate;
36 struct _EntangleCameraSupportPrivate {
37     EntangleCameraList *cameraList;
38 
39     GtkLabel *infoText;
40 };
41 
42 G_DEFINE_TYPE_WITH_PRIVATE(EntangleCameraSupport, entangle_camera_support, GTK_TYPE_DIALOG);
43 
44 enum {
45     PROP_O,
46     PROP_CAMERA_LIST,
47 };
48 
49 
entangle_camera_support_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)50 static void entangle_camera_support_get_property(GObject *object,
51                                                  guint prop_id,
52                                                  GValue *value,
53                                                  GParamSpec *pspec)
54 {
55     EntangleCameraSupport *support = ENTANGLE_CAMERA_SUPPORT(object);
56     EntangleCameraSupportPrivate *priv = entangle_camera_support_get_instance_private(support);
57 
58     switch (prop_id)
59         {
60         case PROP_CAMERA_LIST:
61             g_value_set_object(value, priv->cameraList);
62             break;
63 
64         default:
65             G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
66         }
67 }
68 
69 
entangle_camera_support_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)70 static void entangle_camera_support_set_property(GObject *object,
71                                                  guint prop_id,
72                                                  const GValue *value,
73                                                  GParamSpec *pspec)
74 {
75     EntangleCameraSupport *support = ENTANGLE_CAMERA_SUPPORT(object);
76 
77     ENTANGLE_DEBUG("Set prop %d", prop_id);
78 
79     switch (prop_id)
80         {
81         case PROP_CAMERA_LIST:
82             entangle_camera_support_set_camera_list(support, g_value_get_object(value));
83             break;
84 
85         default:
86             G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
87         }
88 }
89 
90 
entangle_camera_support_finalize(GObject * object)91 static void entangle_camera_support_finalize(GObject *object)
92 {
93     EntangleCameraSupport *support = ENTANGLE_CAMERA_SUPPORT(object);
94     EntangleCameraSupportPrivate *priv = entangle_camera_support_get_instance_private(support);
95 
96     if (priv->cameraList)
97         g_object_unref(priv->cameraList);
98 
99     G_OBJECT_CLASS(entangle_camera_support_parent_class)->finalize(object);
100 }
101 
102 
entangle_camera_support_class_init(EntangleCameraSupportClass * klass)103 static void entangle_camera_support_class_init(EntangleCameraSupportClass *klass)
104 {
105     GObjectClass *object_class = G_OBJECT_CLASS(klass);
106 
107     object_class->finalize = entangle_camera_support_finalize;
108     object_class->get_property = entangle_camera_support_get_property;
109     object_class->set_property = entangle_camera_support_set_property;
110 
111     g_object_class_install_property(object_class,
112                                     PROP_CAMERA_LIST,
113                                     g_param_spec_object("camera-list",
114                                                         "Camera List",
115                                                         "Camera list to query",
116                                                         ENTANGLE_TYPE_CAMERA_LIST,
117                                                         G_PARAM_READWRITE |
118                                                         G_PARAM_STATIC_NAME |
119                                                         G_PARAM_STATIC_NICK |
120                                                         G_PARAM_STATIC_BLURB));
121 
122     gtk_widget_class_set_template_from_resource(GTK_WIDGET_CLASS(klass),
123                                                 "/org/entangle_photo/Manager/frontend/entangle-camera-support.ui");
124 
125     gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass),
126                                                  EntangleCameraSupport, infoText);
127 }
128 
129 
entangle_camera_support_new(void)130 EntangleCameraSupport *entangle_camera_support_new(void)
131 {
132     return ENTANGLE_CAMERA_SUPPORT(g_object_new(ENTANGLE_TYPE_CAMERA_SUPPORT, NULL));
133 }
134 
135 
do_support_close(GtkButton * src G_GNUC_UNUSED,gpointer data)136 gboolean do_support_close(GtkButton *src G_GNUC_UNUSED,
137                           gpointer data)
138 {
139     g_return_val_if_fail(ENTANGLE_IS_CAMERA_SUPPORT(data), FALSE);
140 
141     EntangleCameraSupport *support = ENTANGLE_CAMERA_SUPPORT(data);
142 
143     ENTANGLE_DEBUG("support close");
144 
145     gtk_widget_hide(GTK_WIDGET(support));
146     return FALSE;
147 }
148 
do_support_delete(GtkWidget * src,GdkEvent * ev G_GNUC_UNUSED)149 gboolean do_support_delete(GtkWidget *src,
150                            GdkEvent *ev G_GNUC_UNUSED)
151 {
152     g_return_val_if_fail(ENTANGLE_IS_CAMERA_SUPPORT(src), FALSE);
153 
154     ENTANGLE_DEBUG("support delete");
155 
156     gtk_widget_hide(src);
157     return FALSE;
158 }
159 
160 
entangle_camera_support_init(EntangleCameraSupport * support)161 static void entangle_camera_support_init(EntangleCameraSupport *support)
162 {
163     gtk_widget_init_template(GTK_WIDGET(support));
164 }
165 
166 
do_support_refresh(EntangleCameraSupport * support)167 static void do_support_refresh(EntangleCameraSupport *support)
168 {
169     g_return_if_fail(ENTANGLE_IS_CAMERA_SUPPORT(support));
170 
171     EntangleCameraSupportPrivate *priv = entangle_camera_support_get_instance_private(support);
172 
173     if (priv->cameraList) {
174         GList *cameras, *tmp;
175         GString *str = g_string_new("");
176         cameras = entangle_camera_list_get_cameras(priv->cameraList);
177         tmp = cameras = g_list_reverse(cameras);
178         while (tmp) {
179             EntangleCamera *cam = tmp->data;
180             gboolean cap = entangle_camera_get_has_capture(cam);
181             gboolean pre = entangle_camera_get_has_preview(cam);
182             gboolean set = entangle_camera_get_has_settings(cam);
183             if (cap || pre) {
184                 gboolean done = FALSE;
185                 g_string_append(str, entangle_camera_get_model(cam));
186                 g_string_append(str, " (");
187                 if (cap) {
188                     g_string_append(str, _("capture"));
189                     done = TRUE;
190                 }
191                 if (pre) {
192                     if (done)
193                         g_string_append(str, ", ");
194                     g_string_append(str, _("preview"));
195                     done = TRUE;
196                 }
197                 if (set) {
198                     if (done)
199                         g_string_append(str, ", ");
200                     g_string_append(str, _("settings"));
201                 }
202                 g_string_append(str, ")");
203                 g_string_append(str, "\n");
204             }
205             tmp = tmp->next;
206         }
207         g_list_free(cameras);
208         gtk_label_set_text(priv->infoText, str->str);
209         g_string_free(str, TRUE);
210     } else {
211         gtk_label_set_text(priv->infoText, "");
212     }
213 }
214 
215 
216 /**
217  * entangle_camera_support_set_camera_list:
218  * @support: the camera support widget
219  * @list: (transfer none)(allow-none): the list of cameras
220  *
221  * Set the camera list for the widget
222  */
entangle_camera_support_set_camera_list(EntangleCameraSupport * support,EntangleCameraList * list)223 void entangle_camera_support_set_camera_list(EntangleCameraSupport *support,
224                                              EntangleCameraList *list)
225 {
226     g_return_if_fail(ENTANGLE_IS_CAMERA_SUPPORT(support));
227     g_return_if_fail(ENTANGLE_IS_CAMERA_LIST(list));
228 
229     EntangleCameraSupportPrivate *priv = entangle_camera_support_get_instance_private(support);
230 
231     if (priv->cameraList)
232         g_object_unref(priv->cameraList);
233     priv->cameraList = list;
234     if (priv->cameraList)
235         g_object_ref(priv->cameraList);
236 
237     do_support_refresh(support);
238 }
239 
240 
241 /**
242  * entangle_camera_support_get_camera_list:
243  * @support: the camera support widget
244  *
245  * Get the camera list
246  *
247  * Returns: (transfer none): the camera list or NULL
248  */
entangle_camera_support_get_camera_list(EntangleCameraSupport * support)249 EntangleCameraList *entangle_camera_support_get_camera_list(EntangleCameraSupport *support)
250 {
251     g_return_val_if_fail(ENTANGLE_IS_CAMERA_SUPPORT(support), NULL);
252 
253     EntangleCameraSupportPrivate *priv = entangle_camera_support_get_instance_private(support);
254 
255     return priv->cameraList;
256 }
257 
258 
259 /*
260  * Local variables:
261  *  c-indent-level: 4
262  *  c-basic-offset: 4
263  *  indent-tabs-mode: nil
264  *  tab-width: 8
265  * End:
266  */
267