1 /*
2 Gpredict: Real-time satellite tracking and orbit prediction program
3
4 Copyright (C) 2001-2017 Alexandru Csete, OZ9AEC.
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 2 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, visit http://www.fsf.org/
18 */
19 #ifdef HAVE_CONFIG_H
20 #include <build-config.h>
21 #endif
22 #include <glib/gi18n.h>
23 #include <gtk/gtk.h>
24
25 #include "config-keys.h"
26 #include "mod-cfg-get-param.h"
27 #include "sat-cfg.h"
28 #include "sat-pref-refresh.h"
29
30
31 static GtkWidget *dataspin; /* spin button for module refresh rate */
32 static GtkWidget *listspin; /* spin button for list view */
33 static GtkWidget *mapspin; /* spin button for map view */
34 static GtkWidget *polarspin; /* spin button for polar view */
35 static GtkWidget *singlespin; /* spin button for single-sat view */
36
37 static gboolean dirty = FALSE; /* used to check whether any changes have occurred */
38 static gboolean reset = FALSE;
39
40
41 /* User pressed cancel. Any changes to config must be cancelled. */
sat_pref_refresh_cancel(GKeyFile * cfg)42 void sat_pref_refresh_cancel(GKeyFile * cfg)
43 {
44 (void)cfg;
45
46 dirty = FALSE;
47 }
48
49 /* User pressed OK. Any changes should be stored in config. */
sat_pref_refresh_ok(GKeyFile * cfg)50 void sat_pref_refresh_ok(GKeyFile * cfg)
51 {
52 if (dirty)
53 {
54 if (cfg != NULL)
55 {
56 g_key_file_set_integer(cfg,
57 MOD_CFG_GLOBAL_SECTION,
58 MOD_CFG_TIMEOUT_KEY,
59 gtk_spin_button_get_value_as_int
60 (GTK_SPIN_BUTTON(dataspin)));
61
62 g_key_file_set_integer(cfg,
63 MOD_CFG_LIST_SECTION,
64 MOD_CFG_LIST_REFRESH,
65 gtk_spin_button_get_value_as_int
66 (GTK_SPIN_BUTTON(listspin)));
67
68 g_key_file_set_integer(cfg,
69 MOD_CFG_MAP_SECTION,
70 MOD_CFG_MAP_REFRESH,
71 gtk_spin_button_get_value_as_int
72 (GTK_SPIN_BUTTON(mapspin)));
73
74 g_key_file_set_integer(cfg,
75 MOD_CFG_POLAR_SECTION,
76 MOD_CFG_POLAR_REFRESH,
77 gtk_spin_button_get_value_as_int
78 (GTK_SPIN_BUTTON(polarspin)));
79
80 g_key_file_set_integer(cfg,
81 MOD_CFG_SINGLE_SAT_SECTION,
82 MOD_CFG_SINGLE_SAT_REFRESH,
83 gtk_spin_button_get_value_as_int
84 (GTK_SPIN_BUTTON(singlespin)));
85 }
86 else
87 {
88 sat_cfg_set_int(SAT_CFG_INT_MODULE_TIMEOUT,
89 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON
90 (dataspin)));
91
92 sat_cfg_set_int(SAT_CFG_INT_LIST_REFRESH,
93 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON
94 (listspin)));
95
96 sat_cfg_set_int(SAT_CFG_INT_MAP_REFRESH,
97 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON
98 (mapspin)));
99
100 sat_cfg_set_int(SAT_CFG_INT_POLAR_REFRESH,
101 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON
102 (polarspin)));
103
104 sat_cfg_set_int(SAT_CFG_INT_SINGLE_SAT_REFRESH,
105 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON
106 (singlespin)));
107 }
108 }
109 else if (reset)
110 {
111 /* we have to reset the values to global or default settings */
112 if (cfg == NULL)
113 {
114 /* reset values in sat-cfg */
115 sat_cfg_reset_int(SAT_CFG_INT_MODULE_TIMEOUT);
116 sat_cfg_reset_int(SAT_CFG_INT_LIST_REFRESH);
117 sat_cfg_reset_int(SAT_CFG_INT_MAP_REFRESH);
118 sat_cfg_reset_int(SAT_CFG_INT_POLAR_REFRESH);
119 sat_cfg_reset_int(SAT_CFG_INT_SINGLE_SAT_REFRESH);
120 }
121 else
122 {
123 /* remove keys */
124 g_key_file_remove_key((GKeyFile *) (cfg),
125 MOD_CFG_GLOBAL_SECTION,
126 MOD_CFG_TIMEOUT_KEY, NULL);
127 g_key_file_remove_key((GKeyFile *) (cfg),
128 MOD_CFG_LIST_SECTION,
129 MOD_CFG_LIST_REFRESH, NULL);
130 g_key_file_remove_key((GKeyFile *) (cfg),
131 MOD_CFG_MAP_SECTION,
132 MOD_CFG_MAP_REFRESH, NULL);
133 g_key_file_remove_key((GKeyFile *) (cfg),
134 MOD_CFG_POLAR_SECTION,
135 MOD_CFG_POLAR_REFRESH, NULL);
136 g_key_file_remove_key((GKeyFile *) (cfg),
137 MOD_CFG_SINGLE_SAT_SECTION,
138 MOD_CFG_SINGLE_SAT_REFRESH, NULL);
139 }
140 }
141
142 dirty = FALSE;
143 reset = FALSE;
144 }
145
spin_changed_cb(GtkWidget * spinner,gpointer data)146 static void spin_changed_cb(GtkWidget * spinner, gpointer data)
147 {
148 (void)spinner;
149 (void)data;
150
151 dirty = TRUE;
152 }
153
154 /**
155 * Reset settings.
156 *
157 * @param button The RESET button.
158 * @param cfg Pointer to the module config or NULL in global mode.
159 *
160 * This function is called when the user clicks on the RESET button. In global mode
161 * (when cfg = NULL) the function will reset the settings to the efault values, while
162 * in "local" mode (when cfg != NULL) the function will reset the module settings to
163 * the global settings. This is done by removing the corresponding key from the GKeyFile.
164 */
reset_cb(GtkWidget * button,gpointer cfg)165 static void reset_cb(GtkWidget * button, gpointer cfg)
166 {
167 gint val;
168
169 (void)button;
170
171 /* views */
172 if (cfg == NULL)
173 {
174 /* global mode, get defaults */
175 val = sat_cfg_get_int_def(SAT_CFG_INT_MODULE_TIMEOUT);
176 gtk_spin_button_set_value(GTK_SPIN_BUTTON(dataspin), val);
177 val = sat_cfg_get_int_def(SAT_CFG_INT_LIST_REFRESH);
178 gtk_spin_button_set_value(GTK_SPIN_BUTTON(listspin), val);
179 val = sat_cfg_get_int_def(SAT_CFG_INT_MAP_REFRESH);
180 gtk_spin_button_set_value(GTK_SPIN_BUTTON(mapspin), val);
181 val = sat_cfg_get_int_def(SAT_CFG_INT_POLAR_REFRESH);
182 gtk_spin_button_set_value(GTK_SPIN_BUTTON(polarspin), val);
183 val = sat_cfg_get_int_def(SAT_CFG_INT_SINGLE_SAT_REFRESH);
184 gtk_spin_button_set_value(GTK_SPIN_BUTTON(singlespin), val);
185 }
186 else
187 {
188 /* local mode, get global value */
189 val = sat_cfg_get_int(SAT_CFG_INT_MODULE_TIMEOUT);
190 gtk_spin_button_set_value(GTK_SPIN_BUTTON(dataspin), val);
191 val = sat_cfg_get_int(SAT_CFG_INT_LIST_REFRESH);
192 gtk_spin_button_set_value(GTK_SPIN_BUTTON(listspin), val);
193 val = sat_cfg_get_int(SAT_CFG_INT_MAP_REFRESH);
194 gtk_spin_button_set_value(GTK_SPIN_BUTTON(mapspin), val);
195 val = sat_cfg_get_int(SAT_CFG_INT_POLAR_REFRESH);
196 gtk_spin_button_set_value(GTK_SPIN_BUTTON(polarspin), val);
197 val = sat_cfg_get_int(SAT_CFG_INT_SINGLE_SAT_REFRESH);
198 gtk_spin_button_set_value(GTK_SPIN_BUTTON(singlespin), val);
199 }
200
201 /* reset flags */
202 reset = TRUE;
203 dirty = FALSE;
204 }
205
create_reset_button(GKeyFile * cfg,GtkBox * vbox)206 static void create_reset_button(GKeyFile * cfg, GtkBox * vbox)
207 {
208 GtkWidget *button;
209 GtkWidget *butbox;
210
211 button = gtk_button_new_with_label(_("Reset"));
212 g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(reset_cb), cfg);
213
214 if (cfg == NULL)
215 {
216 gtk_widget_set_tooltip_text(button,
217 _
218 ("Reset settings to the default values."));
219 }
220 else
221 {
222 gtk_widget_set_tooltip_text(button,
223 _
224 ("Reset module settings to the global values."));
225 }
226
227 butbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
228 gtk_button_box_set_layout(GTK_BUTTON_BOX(butbox), GTK_BUTTONBOX_END);
229 gtk_box_pack_end(GTK_BOX(butbox), button, FALSE, TRUE, 10);
230
231 gtk_box_pack_end(vbox, butbox, FALSE, TRUE, 0);
232
233 }
234
sat_pref_refresh_create(GKeyFile * cfg)235 GtkWidget *sat_pref_refresh_create(GKeyFile * cfg)
236 {
237 GtkWidget *table;
238 GtkWidget *vbox;
239 GtkWidget *label;
240 gint val;
241
242 dirty = FALSE;
243 reset = FALSE;
244
245 table = gtk_grid_new();
246 gtk_grid_set_row_spacing(GTK_GRID(table), 10);
247 gtk_grid_set_column_spacing(GTK_GRID(table), 5);
248
249 /* data refresh */
250 label = gtk_label_new(_("Refresh data every"));
251 g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
252 gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1);
253
254 dataspin = gtk_spin_button_new_with_range(100, 10000, 1);
255 gtk_spin_button_set_increments(GTK_SPIN_BUTTON(dataspin), 1, 100);
256 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(dataspin), TRUE);
257 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(dataspin),
258 GTK_UPDATE_IF_VALID);
259 if (cfg != NULL)
260 {
261 val = mod_cfg_get_int(cfg,
262 MOD_CFG_GLOBAL_SECTION,
263 MOD_CFG_TIMEOUT_KEY, SAT_CFG_INT_MODULE_TIMEOUT);
264 }
265 else
266 {
267 val = sat_cfg_get_int(SAT_CFG_INT_MODULE_TIMEOUT);
268 }
269 gtk_spin_button_set_value(GTK_SPIN_BUTTON(dataspin), val);
270 g_signal_connect(G_OBJECT(dataspin), "value-changed",
271 G_CALLBACK(spin_changed_cb), NULL);
272 gtk_grid_attach(GTK_GRID(table), dataspin, 1, 0, 1, 1);
273
274 label = gtk_label_new(_("[msec]"));
275 g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
276 gtk_grid_attach(GTK_GRID(table), label, 2, 0, 1, 1);
277
278 gtk_grid_attach(GTK_GRID(table),
279 gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), 0, 1, 3, 1);
280
281 /* List View */
282 label = gtk_label_new(_("Refresh list view every"));
283 g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
284 gtk_grid_attach(GTK_GRID(table), label, 0, 2, 1, 1);
285
286 listspin = gtk_spin_button_new_with_range(1, 50, 1);
287 gtk_spin_button_set_increments(GTK_SPIN_BUTTON(listspin), 1, 5);
288 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(listspin), TRUE);
289 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(listspin),
290 GTK_UPDATE_IF_VALID);
291 if (cfg != NULL)
292 {
293 val = mod_cfg_get_int(cfg,
294 MOD_CFG_LIST_SECTION,
295 MOD_CFG_LIST_REFRESH, SAT_CFG_INT_LIST_REFRESH);
296 }
297 else
298 {
299 val = sat_cfg_get_int(SAT_CFG_INT_LIST_REFRESH);
300 }
301 gtk_spin_button_set_value(GTK_SPIN_BUTTON(listspin), val);
302 g_signal_connect(G_OBJECT(listspin), "value-changed",
303 G_CALLBACK(spin_changed_cb), NULL);
304 gtk_grid_attach(GTK_GRID(table), listspin, 1, 2, 1, 1);
305
306 label = gtk_label_new(_("[cycle]"));
307 g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
308 gtk_grid_attach(GTK_GRID(table), label, 2, 2, 1, 1);
309
310 /* Map View */
311 label = gtk_label_new(_("Refresh map view every"));
312 g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
313 gtk_grid_attach(GTK_GRID(table), label, 0, 3, 1, 1);
314
315 mapspin = gtk_spin_button_new_with_range(1, 50, 1);
316 gtk_spin_button_set_increments(GTK_SPIN_BUTTON(mapspin), 1, 5);
317 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(mapspin), TRUE);
318 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(mapspin),
319 GTK_UPDATE_IF_VALID);
320 if (cfg != NULL)
321 {
322 val = mod_cfg_get_int(cfg,
323 MOD_CFG_MAP_SECTION,
324 MOD_CFG_MAP_REFRESH, SAT_CFG_INT_MAP_REFRESH);
325 }
326 else
327 {
328 val = sat_cfg_get_int(SAT_CFG_INT_MAP_REFRESH);
329 }
330 gtk_spin_button_set_value(GTK_SPIN_BUTTON(mapspin), val);
331 g_signal_connect(G_OBJECT(mapspin), "value-changed",
332 G_CALLBACK(spin_changed_cb), NULL);
333 gtk_grid_attach(GTK_GRID(table), mapspin, 1, 3, 1, 1);
334
335 label = gtk_label_new(_("[cycle]"));
336 g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
337 gtk_grid_attach(GTK_GRID(table), label, 2, 3, 1, 1);
338
339 /* Polar View */
340 label = gtk_label_new(_("Refresh polar view every"));
341 g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
342 gtk_grid_attach(GTK_GRID(table), label, 0, 4, 1, 1);
343
344 polarspin = gtk_spin_button_new_with_range(1, 50, 1);
345 gtk_spin_button_set_increments(GTK_SPIN_BUTTON(polarspin), 1, 5);
346 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(polarspin), TRUE);
347 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(polarspin),
348 GTK_UPDATE_IF_VALID);
349 if (cfg != NULL)
350 {
351 val = mod_cfg_get_int(cfg,
352 MOD_CFG_POLAR_SECTION,
353 MOD_CFG_POLAR_REFRESH,
354 SAT_CFG_INT_POLAR_REFRESH);
355 }
356 else
357 {
358 val = sat_cfg_get_int(SAT_CFG_INT_POLAR_REFRESH);
359 }
360 gtk_spin_button_set_value(GTK_SPIN_BUTTON(polarspin), val);
361 g_signal_connect(G_OBJECT(polarspin), "value-changed",
362 G_CALLBACK(spin_changed_cb), NULL);
363 gtk_grid_attach(GTK_GRID(table), polarspin, 1, 4, 1, 1);
364
365 label = gtk_label_new(_("[cycle]"));
366 g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
367 gtk_grid_attach(GTK_GRID(table), label, 2, 4, 1, 1);
368
369 /* Single-Sat View */
370 label = gtk_label_new(_("Refresh single-sat view every"));
371 g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
372 gtk_grid_attach(GTK_GRID(table), label, 0, 5, 1, 1);
373
374 singlespin = gtk_spin_button_new_with_range(1, 50, 1);
375 gtk_spin_button_set_increments(GTK_SPIN_BUTTON(singlespin), 1, 5);
376 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(singlespin), TRUE);
377 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(singlespin),
378 GTK_UPDATE_IF_VALID);
379 if (cfg != NULL)
380 {
381 val = mod_cfg_get_int(cfg,
382 MOD_CFG_SINGLE_SAT_SECTION,
383 MOD_CFG_SINGLE_SAT_REFRESH,
384 SAT_CFG_INT_SINGLE_SAT_REFRESH);
385 }
386 else
387 {
388 val = sat_cfg_get_int(SAT_CFG_INT_SINGLE_SAT_REFRESH);
389 }
390 gtk_spin_button_set_value(GTK_SPIN_BUTTON(singlespin), val);
391 g_signal_connect(G_OBJECT(singlespin), "value-changed",
392 G_CALLBACK(spin_changed_cb), NULL);
393 gtk_grid_attach(GTK_GRID(table), singlespin, 1, 5, 1, 1);
394
395 label = gtk_label_new(_("[cycle]"));
396 g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
397 gtk_grid_attach(GTK_GRID(table), label, 2, 5, 1, 1);
398
399 /* create vertical box */
400 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
401 gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE);
402 gtk_container_set_border_width(GTK_CONTAINER(vbox), 20);
403 gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
404
405 /* create RESET button */
406 create_reset_button(cfg, GTK_BOX(vbox));
407
408 return vbox;
409 }
410