« back to all changes in this revision
Viewing changes to src/gtk-sat-module-popup.c
- browse files at revision 1.2.4
- compare with another revision
- download diff
- download tarball
- view history from revision 1.2.4
- Committer: Bazaar Package Importer
- Author(s): Fernando M. Maresca
- Date: 2011-02-21 12:32:33 UTC
- mto: (3.1.7 sid)
- mto: This revision was merged to the branch mainline in revision 18.
- Revision ID: james.westby@ubuntu.com-20110221123233-50ztzx1wch3jqcs8
Tags: upstream-1.2
Import upstream version 1.2
- files added:
- data/desktop
- files removed:
- pixmaps/icons/gpredict-layout-1.png
- files modified:
- AUTHORS
added
removed
src/gtk-sat-module-popup.c
11
11
More details can be found at the project home page:
12
12
13
13
http://gpredict.oz9aec.net/
14
14
15
15
This program is free software; you can redistribute it and/or modify
16
16
it under the terms of the GNU General Public License as published by
17
17
the Free Software Foundation; either version 2 of the License, or
18
18
(at your option) any later version.
19
19
20
20
This program is distributed in the hope that it will be useful,
21
21
but WITHOUT ANY WARRANTY; without even the implied warranty of
22
22
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23
23
GNU General Public License for more details.
24
24
25
25
You should have received a copy of the GNU General Public License
26
26
along with this program; if not, visit http://www.fsf.org/
27
27
*/
75
75
* parent.
76
76
*
77
77
*/
78
void
79
gtk_sat_module_popup (GtkSatModule *module)
78
void gtk_sat_module_popup (GtkSatModule *module)
80
79
{
81
GtkWidget *menu;
82
GtkWidget *menuitem;
83
GtkWidget *image;
84
gchar *buff;
85
86
87
88
if ((module == NULL) || !IS_GTK_SAT_MODULE (module)) {
89
sat_log_log (SAT_LOG_LEVEL_BUG,
90
_("%s:%d: %s called with NULL parameter!"),
91
__FILE__, __LINE__, __FUNCTION__);
92
93
return;
94
}
95
96
menu = gtk_menu_new ();
97
98
if (module->state == GTK_SAT_MOD_STATE_DOCKED) {
99
100
menuitem = gtk_image_menu_item_new_with_label (_("Detach module"));
101
buff = icon_file_name ("gpredict-notebook.png");
102
image = gtk_image_new_from_file (buff);
103
g_free (buff);
104
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
105
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
106
g_signal_connect (menuitem, "activate",
107
G_CALLBACK (docking_state_cb), module);
108
}
109
else {
110
111
menuitem = gtk_image_menu_item_new_with_label (_("Attach module"));
112
buff = icon_file_name ("gpredict-notebook.png");
113
image = gtk_image_new_from_file (buff);
114
g_free (buff);
115
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
116
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
117
g_signal_connect (menuitem, "activate",
118
G_CALLBACK (docking_state_cb), module);
119
120
}
121
122
if (module->state == GTK_SAT_MOD_STATE_FULLSCREEN) {
123
124
menuitem = gtk_image_menu_item_new_with_label (_("Leave fullscreen"));
125
image = gtk_image_new_from_stock (GTK_STOCK_LEAVE_FULLSCREEN,
126
GTK_ICON_SIZE_MENU);
127
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
128
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
129
g_signal_connect (menuitem, "activate",
130
G_CALLBACK (screen_state_cb), module);
131
}
132
else {
133
menuitem = gtk_image_menu_item_new_with_label (_("Fullscreen"));
134
image = gtk_image_new_from_stock (GTK_STOCK_FULLSCREEN,
135
GTK_ICON_SIZE_MENU);
136
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
137
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
138
g_signal_connect (menuitem, "activate",
139
G_CALLBACK (screen_state_cb), module);
140
}
141
142
/* separator */
143
menuitem = gtk_separator_menu_item_new ();
144
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
145
146
/* sky at a glance */
147
menuitem = gtk_image_menu_item_new_with_label (_("Sky at a glance"));
148
buff = icon_file_name ("gpredict-planner-small.png");
149
image = gtk_image_new_from_file (buff);
150
g_free (buff);
151
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
152
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
153
g_signal_connect (menuitem, "activate",
154
G_CALLBACK (sky_at_glance_cb), module);
155
156
/* time manager */
157
menuitem = gtk_image_menu_item_new_with_label (_("Time Controller"));
158
buff = icon_file_name ("gpredict-clock-small.png");
159
image = gtk_image_new_from_file (buff);
160
g_free (buff);
161
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
162
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
163
g_signal_connect (menuitem, "activate", G_CALLBACK (tmgr_cb), module);
80
GtkWidget *menu;
81
GtkWidget *menuitem;
82
GtkWidget *image;
83
gchar *buff;
84
85
86
87
if ((module == NULL) || !IS_GTK_SAT_MODULE (module)) {
88
sat_log_log (SAT_LOG_LEVEL_BUG,
89
_("%s:%d: %s called with NULL parameter!"),
90
__FILE__, __LINE__, __FUNCTION__);
91
92
return;
93
}
94
95
menu = gtk_menu_new ();
96
97
if (module->state == GTK_SAT_MOD_STATE_DOCKED) {
98
99
menuitem = gtk_image_menu_item_new_with_label (_("Detach module"));
100
buff = icon_file_name ("gpredict-notebook.png");
101
image = gtk_image_new_from_file (buff);
102
g_free (buff);
103
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
104
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
105
g_signal_connect (menuitem, "activate",
106
G_CALLBACK (docking_state_cb), module);
107
}
108
else {
109
110
menuitem = gtk_image_menu_item_new_with_label (_("Attach module"));
111
buff = icon_file_name ("gpredict-notebook.png");
112
image = gtk_image_new_from_file (buff);
113
g_free (buff);
114
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
115
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
116
g_signal_connect (menuitem, "activate",
117
G_CALLBACK (docking_state_cb), module);
118
119
}
120
121
if (module->state == GTK_SAT_MOD_STATE_FULLSCREEN) {
122
123
menuitem = gtk_image_menu_item_new_with_label (_("Exit full screen"));
124
image = gtk_image_new_from_stock (GTK_STOCK_LEAVE_FULLSCREEN,
125
GTK_ICON_SIZE_MENU);
126
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
127
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
128
g_signal_connect (menuitem, "activate",
129
G_CALLBACK (screen_state_cb), module);
130
}
131
else {
132
menuitem = gtk_image_menu_item_new_with_label (_("Full screen"));
133
image = gtk_image_new_from_stock (GTK_STOCK_FULLSCREEN,
134
GTK_ICON_SIZE_MENU);
135
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
136
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
137
g_signal_connect (menuitem, "activate",
138
G_CALLBACK (screen_state_cb), module);
139
}
140
141
/* separator */
142
menuitem = gtk_separator_menu_item_new ();
143
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
144
145
/* sky at a glance */
146
menuitem = gtk_image_menu_item_new_with_label (_("Sky at a glance"));
147
buff = icon_file_name ("gpredict-planner-small.png");
148
image = gtk_image_new_from_file (buff);
149
g_free (buff);
150
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
151
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
152
g_signal_connect (menuitem, "activate",
153
G_CALLBACK (sky_at_glance_cb), module);
154
155
/* time manager */
156
menuitem = gtk_image_menu_item_new_with_label (_("Time Controller"));
157
buff = icon_file_name ("gpredict-clock-small.png");
158
image = gtk_image_new_from_file (buff);
159
g_free (buff);
160
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
161
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
162
g_signal_connect (menuitem, "activate", G_CALLBACK (tmgr_cb), module);
164
163
165
164
/* separator */
166
165
menuitem = gtk_separator_menu_item_new ();
183
182
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
184
183
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
185
184
g_signal_connect (menuitem, "activate", G_CALLBACK (rotctrl_cb), module);
186
187
/* separator */
188
menuitem = gtk_separator_menu_item_new ();
189
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
190
191
/* configure */
192
menuitem = gtk_image_menu_item_new_with_label (_("Configure"));
193
image = gtk_image_new_from_stock (GTK_STOCK_PROPERTIES,
194
GTK_ICON_SIZE_MENU);
195
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
196
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
197
g_signal_connect (menuitem, "activate",
198
G_CALLBACK (config_cb), module);
199
200
/* clone */
201
menuitem = gtk_image_menu_item_new_with_label (_("Clone..."));
202
image = gtk_image_new_from_stock (GTK_STOCK_COPY,
203
GTK_ICON_SIZE_MENU);
204
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
205
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
206
g_signal_connect (menuitem, "activate",
207
G_CALLBACK (clone_cb), module);
208
209
/* separator */
210
menuitem = gtk_separator_menu_item_new ();
211
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
212
213
/* delete module */
214
menuitem = gtk_image_menu_item_new_with_label (_("Delete"));
215
image = gtk_image_new_from_stock (GTK_STOCK_DELETE,
216
GTK_ICON_SIZE_MENU);
217
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
218
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
219
g_signal_connect (menuitem, "activate",
220
G_CALLBACK (delete_cb), module);
221
222
/* close */
223
menuitem = gtk_image_menu_item_new_with_label (_("Close"));
224
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE,
225
GTK_ICON_SIZE_MENU);
226
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
227
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
228
g_signal_connect (menuitem, "activate",
229
G_CALLBACK (close_cb), module);
230
231
gtk_widget_show_all (menu);
232
233
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
234
0, gdk_event_get_time (NULL));
185
186
/* separator */
187
menuitem = gtk_separator_menu_item_new ();
188
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
189
190
/* configure */
191
menuitem = gtk_image_menu_item_new_with_label (_("Configure"));
192
image = gtk_image_new_from_stock (GTK_STOCK_PROPERTIES,
193
GTK_ICON_SIZE_MENU);
194
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
195
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
196
g_signal_connect (menuitem, "activate",
197
G_CALLBACK (config_cb), module);
198
199
/* clone */
200
menuitem = gtk_image_menu_item_new_with_label (_("Clone..."));
201
image = gtk_image_new_from_stock (GTK_STOCK_COPY,
202
GTK_ICON_SIZE_MENU);
203
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
204
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
205
g_signal_connect (menuitem, "activate",
206
G_CALLBACK (clone_cb), module);
207
208
/* separator */
209
menuitem = gtk_separator_menu_item_new ();
210
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
211
212
/* delete module */
213
menuitem = gtk_image_menu_item_new_with_label (_("Delete"));
214
image = gtk_image_new_from_stock (GTK_STOCK_DELETE,
215
GTK_ICON_SIZE_MENU);
216
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
217
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
218
g_signal_connect (menuitem, "activate",
219
G_CALLBACK (delete_cb), module);
220
221
/* close */
222
menuitem = gtk_image_menu_item_new_with_label (_("Close"));
223
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE,
224
GTK_ICON_SIZE_MENU);
225
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
226
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
227
g_signal_connect (menuitem, "activate",
228
G_CALLBACK (close_cb), module);
229
230
gtk_widget_show_all (menu);
231
232
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
233
0, gdk_event_get_time (NULL));
235
234
}
236
235
237
236
243
242
* wrapper for gtk_sat_module_config_cb
244
243
*
245
244
*/
246
static void
247
config_cb (GtkWidget *menuitem, gpointer data)
245
static void config_cb (GtkWidget *menuitem, gpointer data)
248
246
{
249
247
GtkSatModule *module = GTK_SAT_MODULE (data);
250
248
262
260
gtk_widget_destroy (dialog);
263
261
}
264
262
else {
265
gtk_sat_module_config_cb (menuitem, data);
263
gtk_sat_module_config_cb (menuitem, data);
266
264
}
267
265
}
268
266
279
277
* possibility to override this in the dialog window.
280
278
*
281
279
*/
282
static void
283
clone_cb (GtkWidget *menuitem, gpointer data)
280
static void clone_cb (GtkWidget *menuitem, gpointer data)
284
281
{
285
GtkWidget *dialog;
286
GtkWidget *entry;
287
GtkWidget *label;
288
GtkWidget *toggle;
289
GtkTooltips *tooltips;
290
guint response;
291
GtkSatModule *module = GTK_SAT_MODULE (data);
292
GtkSatModule *newmod;
293
gchar *source,*target;
294
gchar *icon; /* icon file name */
295
gchar *title; /* window title */
296
297
298
dialog = gtk_dialog_new_with_buttons (_("Clone Module"),
299
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (module))),
300
GTK_DIALOG_MODAL |
301
GTK_DIALOG_DESTROY_WITH_PARENT,
302
GTK_STOCK_CANCEL,
303
GTK_RESPONSE_CANCEL,
304
GTK_STOCK_OK,
305
GTK_RESPONSE_OK,
306
NULL);
307
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
308
309
/* label */
310
label = gtk_label_new (_("Name of new module:"));
311
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, FALSE, FALSE, 0);
312
313
/* name entry */
314
entry = gtk_entry_new ();
315
gtk_entry_set_max_length (GTK_ENTRY (entry), 25);
316
gtk_entry_set_text (GTK_ENTRY (entry), module->name);
317
tooltips = gtk_tooltips_new ();
318
gtk_tooltips_set_tip (tooltips, entry,
319
_("Enter a short name for this module.\n"\
320
"Allowed characters: 0..9, a..z, A..Z, - and _"),
321
_("The name will be used to identify the module "\
322
"and it is also used a file name for saving the data."\
323
"Max length is 25 characters."));
324
325
/* attach changed signal so that we can enable OK button when
282
GtkWidget *dialog;
283
GtkWidget *entry;
284
GtkWidget *label;
285
GtkWidget *toggle;
286
GtkTooltips *tooltips;
287
guint response;
288
GtkSatModule *module = GTK_SAT_MODULE (data);
289
GtkSatModule *newmod;
290
gchar *source,*target;
291
gchar *icon; /* icon file name */
292
gchar *title; /* window title */
293
294
295
dialog = gtk_dialog_new_with_buttons (_("Clone Module"),
296
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (module))),
297
GTK_DIALOG_MODAL |
298
GTK_DIALOG_DESTROY_WITH_PARENT,
299
GTK_STOCK_CANCEL,
300
GTK_RESPONSE_CANCEL,
301
GTK_STOCK_OK,
302
GTK_RESPONSE_OK,
303
NULL);
304
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
305
306
/* label */
307
label = gtk_label_new (_("Name of new module:"));
308
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, FALSE, FALSE, 0);
309
310
/* name entry */
311
entry = gtk_entry_new ();
312
gtk_entry_set_max_length (GTK_ENTRY (entry), 25);
313
gtk_entry_set_text (GTK_ENTRY (entry), module->name);
314
tooltips = gtk_tooltips_new ();
315
gtk_tooltips_set_tip (tooltips, entry,
316
_("Enter a short name for this module.\n"\
317
"Allowed characters: 0..9, a..z, A..Z, - and _"),
318
_("The name will be used to identify the module "\
319
"and it is also used a file name for saving the data."\
320
"Max length is 25 characters."));
321
322
/* attach changed signal so that we can enable OK button when
326
323
a proper name has been entered
327
324
oh, btw. disable OK button to begin with....
328
325
*/
329
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
330
GTK_RESPONSE_OK,
331
FALSE);
332
g_signal_connect (entry, "changed", G_CALLBACK (name_changed), dialog);
333
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
334
entry, FALSE, FALSE, 0);
335
336
337
/* check button */
338
toggle = gtk_check_button_new_with_label (_("Open module when created"));
339
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), TRUE);
340
tooltips = gtk_tooltips_new ();
341
gtk_tooltips_set_tip (tooltips, toggle,
342
_("If checked, the new module will be opened "\
343
"after it has been created"),
344
NULL);
345
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
346
toggle, FALSE, FALSE, 20);
347
348
349
gtk_widget_show_all (GTK_DIALOG (dialog)->vbox);
350
351
/* run dialog */
352
response = gtk_dialog_run (GTK_DIALOG (dialog));
353
354
switch (response) {
355
356
case GTK_RESPONSE_OK:
357
sat_log_log (SAT_LOG_LEVEL_MSG,
358
_("%s:%d: Cloning %s => %s"),
359
__FILE__, __LINE__, module->name,
360
gtk_entry_get_text (GTK_ENTRY (entry)));
361
362
/* build full file names */
363
gchar *moddir = get_modules_dir ();
364
source = g_strconcat (moddir, G_DIR_SEPARATOR_S,
365
module->name, ".mod", NULL);
366
target = g_strconcat (moddir, G_DIR_SEPARATOR_S,
367
gtk_entry_get_text (GTK_ENTRY (entry)), ".mod", NULL);
368
g_free (moddir);
369
370
/* copy file */
371
if (gpredict_file_copy (source, target)) {
372
sat_log_log (SAT_LOG_LEVEL_ERROR,
373
_("%s:%d: Failed to clone %s."),
374
__FILE__, __LINE__, module->name);
375
}
376
else {
377
sat_log_log (SAT_LOG_LEVEL_MSG,
378
_("%s:%d: Successfully cloned %s."),
379
__FILE__, __LINE__, module->name);
380
381
/* open module if requested */
382
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle))) {
383
384
newmod = GTK_SAT_MODULE (gtk_sat_module_new (target));
385
newmod->state = module->state;
386
387
if (newmod->state == GTK_SAT_MOD_STATE_DOCKED) {
388
389
/* add to module manager */
390
mod_mgr_add_module (GTK_WIDGET (newmod), TRUE);
391
392
/* try to reproduce divisions betwenn views */
393
switch (module->layout) {
394
395
case GTK_SAT_MOD_LAYOUT_2:
396
gtk_paned_set_position (GTK_PANED (newmod->vpaned),
397
gtk_paned_get_position (GTK_PANED (module->vpaned)));
398
break;
399
400
case GTK_SAT_MOD_LAYOUT_3:
401
case GTK_SAT_MOD_LAYOUT_4:
402
gtk_paned_set_position (GTK_PANED (newmod->vpaned),
403
gtk_paned_get_position (GTK_PANED (module->vpaned)));
404
gtk_paned_set_position (GTK_PANED (newmod->hpaned),
405
gtk_paned_get_position (GTK_PANED (module->hpaned)));
406
break;
407
408
default:
409
break;
410
411
}
412
413
}
414
else {
415
/* add to module manager */
416
mod_mgr_add_module (GTK_WIDGET (newmod), FALSE);
417
418
/* create window */
419
newmod->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
420
gtk_window_set_title (GTK_WINDOW (newmod->win),
421
newmod->name);
422
title = g_strconcat ("GPREDICT: ",
423
newmod->name,
424
" (", newmod->qth->name, ")",
425
NULL);
426
gtk_window_set_title (GTK_WINDOW (newmod->win), title);
427
g_free (title);
428
429
/* use size of source module */
430
gtk_window_set_default_size (GTK_WINDOW (newmod->win),
431
GTK_WIDGET (module)->allocation.width,
432
GTK_WIDGET (module)->allocation.height);
433
434
g_signal_connect (G_OBJECT (newmod->win), "configure_event",
435
G_CALLBACK (module_window_config_cb), newmod);
436
437
/* add module to window */
438
gtk_container_add (GTK_CONTAINER (newmod->win),
439
GTK_WIDGET (newmod));
440
441
/* window icon */
442
icon = icon_file_name ("gpredict-icon.png");
443
if (g_file_test (icon, G_FILE_TEST_EXISTS)) {
444
gtk_window_set_icon_from_file (GTK_WINDOW (newmod->win), icon, NULL);
445
}
446
g_free (icon);
447
448
/* show window */
449
gtk_widget_show_all (newmod->win);
450
451
}
452
}
453
}
454
455
/* clean up */
456
g_free (source);
457
g_free (target);
458
459
break;
326
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
327
GTK_RESPONSE_OK,
328
FALSE);
329
g_signal_connect (entry, "changed", G_CALLBACK (name_changed), dialog);
330
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
331
entry, FALSE, FALSE, 0);
332
333
334
/* check button */
335
toggle = gtk_check_button_new_with_label (_("Open module when created"));
336
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), TRUE);
337
tooltips = gtk_tooltips_new ();
338
gtk_tooltips_set_tip (tooltips, toggle,
339
_("If checked, the new module will be opened "\
340
"after it has been created"),
341
NULL);
342
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
343
toggle, FALSE, FALSE, 20);
344
345
346
gtk_widget_show_all (GTK_DIALOG (dialog)->vbox);
347
348
/* run dialog */
349
response = gtk_dialog_run (GTK_DIALOG (dialog));
350
351
switch (response) {
352
353
case GTK_RESPONSE_OK:
354
sat_log_log (SAT_LOG_LEVEL_MSG,
355
_("%s:%d: Cloning %s => %s"),
356
__FILE__, __LINE__, module->name,
357
gtk_entry_get_text (GTK_ENTRY (entry)));
358
359
/* build full file names */
360
gchar *moddir = get_modules_dir ();
361
source = g_strconcat (moddir, G_DIR_SEPARATOR_S,
362
module->name, ".mod", NULL);
363
target = g_strconcat (moddir, G_DIR_SEPARATOR_S,
364
gtk_entry_get_text (GTK_ENTRY (entry)), ".mod", NULL);
365
g_free (moddir);
366
367
/* copy file */
368
if (gpredict_file_copy (source, target)) {
369
sat_log_log (SAT_LOG_LEVEL_ERROR,
370
_("%s:%d: Failed to clone %s."),
371
__FILE__, __LINE__, module->name);
372
}
373
else {
374
sat_log_log (SAT_LOG_LEVEL_MSG,
375
_("%s:%d: Successfully cloned %s."),
376
__FILE__, __LINE__, module->name);
377
378
/* open module if requested */
379
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle))) {
380
381
newmod = GTK_SAT_MODULE (gtk_sat_module_new (target));
382
newmod->state = module->state;
383
384
if (newmod->state == GTK_SAT_MOD_STATE_DOCKED) {
385
386
/* add to module manager */
387
mod_mgr_add_module (GTK_WIDGET (newmod), TRUE);
388
389
}
390
else {
391
/* add to module manager */
392
mod_mgr_add_module (GTK_WIDGET (newmod), FALSE);
393
394
/* create window */
395
newmod->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
396
gtk_window_set_title (GTK_WINDOW (newmod->win),
397
newmod->name);
398
title = g_strconcat ("GPREDICT: ",
399
newmod->name,
400
" (", newmod->qth->name, ")",
401
NULL);
402
gtk_window_set_title (GTK_WINDOW (newmod->win), title);
403
g_free (title);
404
405
/* use size of source module */
406
gtk_window_set_default_size (GTK_WINDOW (newmod->win),
407
GTK_WIDGET (module)->allocation.width,
408
GTK_WIDGET (module)->allocation.height);
409
410
g_signal_connect (G_OBJECT (newmod->win), "configure_event",
411
G_CALLBACK (module_window_config_cb), newmod);
412
413
/* add module to window */
414
gtk_container_add (GTK_CONTAINER (newmod->win),
415
GTK_WIDGET (newmod));
416
417
/* window icon */
418
icon = icon_file_name ("gpredict-icon.png");
419
if (g_file_test (icon, G_FILE_TEST_EXISTS)) {
420
gtk_window_set_icon_from_file (GTK_WINDOW (newmod->win), icon, NULL);
421
}
422
g_free (icon);
423
424
/* show window */
425
gtk_widget_show_all (newmod->win);
426
427
}
428
}
429
}
430
431
/* clean up */
432
g_free (source);
433
g_free (target);
434
435
break;
460
436
461
437
case GTK_RESPONSE_CANCEL:
462
sat_log_log (SAT_LOG_LEVEL_MSG,
463
_("%s:%d: Cloning cancelled by user."),
464
__FILE__, __LINE__);
465
break;
438
sat_log_log (SAT_LOG_LEVEL_MSG,
439
_("%s:%d: Cloning cancelled by user."),
440
__FILE__, __LINE__);
441
break;
466
442
467
443
default:
468
sat_log_log (SAT_LOG_LEVEL_MSG,
469
_("%s:%d: Cloning interrupted."),
470
__FILE__, __LINE__);
471
break;
472
}
444
sat_log_log (SAT_LOG_LEVEL_MSG,
445
_("%s:%d: Cloning interrupted."),
446
__FILE__, __LINE__);
447
break;
448
}
473
449
474
gtk_widget_destroy (dialog);
450
gtk_widget_destroy (dialog);
475
451
476
452
}
477
453
487
463
* The text of the menu item will be changed corresponding to the
488
464
* action that has been performed.
489
465
*/
490
static void
491
docking_state_cb (GtkWidget *menuitem, gpointer data)
466
static void docking_state_cb (GtkWidget *menuitem, gpointer data)
492
467
{
493
GtkWidget *module = GTK_WIDGET (data);
494
gint w,h;
495
gchar *icon; /* icon file name */
496
gchar *title; /* window title */
497
498
499
500
switch (GTK_SAT_MODULE (module)->state) {
501
502
case GTK_SAT_MOD_STATE_DOCKED:
468
GtkWidget *module = GTK_WIDGET (data);
469
gint w,h;
470
gchar *icon; /* icon file name */
471
gchar *title; /* window title */
472
473
474
475
switch (GTK_SAT_MODULE (module)->state) {
476
477
case GTK_SAT_MOD_STATE_DOCKED:
503
478
504
479
/* get stored size; use size from main window if size not explicitly stoed */
505
480
if (g_key_file_has_key (GTK_SAT_MODULE (module)->cfgdata,
506
MOD_CFG_GLOBAL_SECTION,
507
MOD_CFG_WIN_WIDTH,
508
NULL)) {
481
MOD_CFG_GLOBAL_SECTION,
482
MOD_CFG_WIN_WIDTH,
483
NULL)) {
509
484
w = g_key_file_get_integer (GTK_SAT_MODULE (module)->cfgdata,
510
MOD_CFG_GLOBAL_SECTION,
511
MOD_CFG_WIN_WIDTH,
512
NULL);
485
MOD_CFG_GLOBAL_SECTION,
486
MOD_CFG_WIN_WIDTH,
487
NULL);
513
488
}
514
489
else {
515
490
w = module->allocation.width;
516
491
}
517
492
if (g_key_file_has_key (GTK_SAT_MODULE (module)->cfgdata,
518
MOD_CFG_GLOBAL_SECTION,
519
MOD_CFG_WIN_HEIGHT,
520
NULL)) {
493
MOD_CFG_GLOBAL_SECTION,
494
MOD_CFG_WIN_HEIGHT,
495
NULL)) {
521
496
h = g_key_file_get_integer (GTK_SAT_MODULE (module)->cfgdata,
522
MOD_CFG_GLOBAL_SECTION,
523
MOD_CFG_WIN_HEIGHT,
524
NULL);
497
MOD_CFG_GLOBAL_SECTION,
498
MOD_CFG_WIN_HEIGHT,
499
NULL);
525
500
}
526
501
else {
527
502
h = module->allocation.height;
528
503
}
529
504
530
/* increase reference count of module */
531
g_object_ref (module);
532
533
/* we don't need the positions */
534
GTK_SAT_MODULE (module)->vpanedpos = -1;
535
GTK_SAT_MODULE (module)->hpanedpos = -1;
536
537
/* undock from mod-mgr */
538
mod_mgr_undock_module (module);
539
540
/* create window */
541
GTK_SAT_MODULE (module)->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
542
title = g_strconcat ("GPREDICT: ",
543
GTK_SAT_MODULE (module)->name,
544
" (", GTK_SAT_MODULE (module)->qth->name, ")",
545
NULL);
546
gtk_window_set_title (GTK_WINDOW (GTK_SAT_MODULE (module)->win), title);
547
g_free (title);
548
gtk_window_set_default_size (GTK_WINDOW (GTK_SAT_MODULE (module)->win), w, h);
505
/* increase reference count of module */
506
g_object_ref (module);
507
508
/* we don't need the positions */
509
//GTK_SAT_MODULE (module)->vpanedpos = -1;
510
//GTK_SAT_MODULE (module)->hpanedpos = -1;
511
512
/* undock from mod-mgr */
513
mod_mgr_undock_module (module);
514
515
/* create window */
516
GTK_SAT_MODULE (module)->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
517
title = g_strconcat ("GPREDICT: ",
518
GTK_SAT_MODULE (module)->name,
519
" (", GTK_SAT_MODULE (module)->qth->name, ")",
520
NULL);
521
gtk_window_set_title (GTK_WINDOW (GTK_SAT_MODULE (module)->win), title);
522
g_free (title);
523
gtk_window_set_default_size (GTK_WINDOW (GTK_SAT_MODULE (module)->win), w, h);
549
524
g_signal_connect (G_OBJECT (GTK_SAT_MODULE (module)->win), "configure_event",
550
525
G_CALLBACK (module_window_config_cb), module);
551
526
552
/* window icon */
553
icon = icon_file_name ("gpredict-icon.png");
554
if (g_file_test (icon, G_FILE_TEST_EXISTS)) {
555
gtk_window_set_icon_from_file (GTK_WINDOW (GTK_SAT_MODULE (module)->win), icon, NULL);
556
}
557
g_free (icon);
527
/* window icon */
528
icon = icon_file_name ("gpredict-icon.png");
529
if (g_file_test (icon, G_FILE_TEST_EXISTS)) {
530
gtk_window_set_icon_from_file (GTK_WINDOW (GTK_SAT_MODULE (module)->win), icon, NULL);
531
}
532
g_free (icon);
558
533
559
534
/* move window to stored position if requested by configuration */
560
535
if (sat_cfg_get_bool (SAT_CFG_BOOL_MOD_WIN_POS) &&
561
536
g_key_file_has_key (GTK_SAT_MODULE (module)->cfgdata,
562
MOD_CFG_GLOBAL_SECTION,
563
MOD_CFG_WIN_POS_X,
564
NULL) &&
537
MOD_CFG_GLOBAL_SECTION,
538
MOD_CFG_WIN_POS_X,
539
NULL) &&
565
540
g_key_file_has_key (GTK_SAT_MODULE (module)->cfgdata,
566
MOD_CFG_GLOBAL_SECTION,
567
MOD_CFG_WIN_POS_Y,
568
NULL)) {
569
541
MOD_CFG_GLOBAL_SECTION,
542
MOD_CFG_WIN_POS_Y,
543
NULL)) {
544
570
545
gtk_window_move (GTK_WINDOW (GTK_SAT_MODULE (module)->win),
571
546
g_key_file_get_integer (GTK_SAT_MODULE (module)->cfgdata,
572
MOD_CFG_GLOBAL_SECTION,
573
MOD_CFG_WIN_POS_X, NULL),
547
MOD_CFG_GLOBAL_SECTION,
548
MOD_CFG_WIN_POS_X, NULL),
574
549
g_key_file_get_integer (GTK_SAT_MODULE (module)->cfgdata,
575
MOD_CFG_GLOBAL_SECTION,
576
MOD_CFG_WIN_POS_Y,
577
NULL));
550
MOD_CFG_GLOBAL_SECTION,
551
MOD_CFG_WIN_POS_Y,
552
NULL));
578
553
579
554
}
580
555
581
/* add module to window */
582
gtk_container_add (GTK_CONTAINER (GTK_SAT_MODULE (module)->win), module);
556
/* add module to window */
557
gtk_container_add (GTK_CONTAINER (GTK_SAT_MODULE (module)->win), module);
583
558
584
/* change internal state */
585
GTK_SAT_MODULE (module)->state = GTK_SAT_MOD_STATE_WINDOW;
559
/* change internal state */
560
GTK_SAT_MODULE (module)->state = GTK_SAT_MOD_STATE_WINDOW;
586
561
587
562
/* store new state in configuration */
588
563
g_key_file_set_integer (GTK_SAT_MODULE (module)->cfgdata,
589
MOD_CFG_GLOBAL_SECTION,
590
MOD_CFG_STATE,
591
GTK_SAT_MOD_STATE_WINDOW);
592
593
/* decrease reference count of module */
594
g_object_unref (module);
595
596
/* show window */
597
gtk_widget_show_all (GTK_SAT_MODULE (module)->win);
564
MOD_CFG_GLOBAL_SECTION,
565
MOD_CFG_STATE,
566
GTK_SAT_MOD_STATE_WINDOW);
567
568
/* decrease reference count of module */
569
g_object_unref (module);
570
571
/* show window */
572
gtk_widget_show_all (GTK_SAT_MODULE (module)->win);
598
573
599
/* reparent time manager window if visible */
600
if (GTK_SAT_MODULE (module)->tmgActive) {
601
gtk_window_set_transient_for (GTK_WINDOW (GTK_SAT_MODULE (module)->tmgWin),
602
GTK_WINDOW (GTK_SAT_MODULE (module)->win));
603
}
574
/* reparent time manager window if visible */
575
if (GTK_SAT_MODULE (module)->tmgActive) {
576
gtk_window_set_transient_for (GTK_WINDOW (GTK_SAT_MODULE (module)->tmgWin),
577
GTK_WINDOW (GTK_SAT_MODULE (module)->win));
578
}
604
579
605
break;
580
break;
606
581
607
582
case GTK_SAT_MOD_STATE_WINDOW:
608
583
case GTK_SAT_MOD_STATE_FULLSCREEN:
609
584
610
/* increase referene count */
611
g_object_ref (module);
612
613
/* store paned positions */
614
if (GTK_SAT_MODULE (module)->layout == GTK_SAT_MOD_LAYOUT_2) {
615
GTK_SAT_MODULE (module)->vpanedpos = gtk_paned_get_position (GTK_PANED (GTK_SAT_MODULE (module)->vpaned));
616
}
617
else if ((GTK_SAT_MODULE (module)->layout == GTK_SAT_MOD_LAYOUT_3) ||
618
(GTK_SAT_MODULE (module)->layout == GTK_SAT_MOD_LAYOUT_4)) {
619
620
GTK_SAT_MODULE (module)->vpanedpos = gtk_paned_get_position (GTK_PANED (GTK_SAT_MODULE (module)->vpaned));
621
GTK_SAT_MODULE (module)->hpanedpos = gtk_paned_get_position (GTK_PANED (GTK_SAT_MODULE (module)->hpaned));
622
}
623
624
/* reparent time manager window if visible */
625
if (GTK_SAT_MODULE (module)->tmgActive) {
626
gtk_window_set_transient_for (GTK_WINDOW (GTK_SAT_MODULE (module)->tmgWin),
627
GTK_WINDOW (app));
628
}
629
630
/* remove module from window, destroy window */
631
gtk_container_remove (GTK_CONTAINER (GTK_SAT_MODULE (module)->win), module);
632
gtk_widget_destroy (GTK_SAT_MODULE (module)->win);
633
GTK_SAT_MODULE (module)->win = NULL;
634
635
/* dock into mod-mgr */
636
mod_mgr_dock_module (module);
637
638
/* change internal state */
639
GTK_SAT_MODULE (module)->state = GTK_SAT_MOD_STATE_DOCKED;
585
/* increase referene count */
586
g_object_ref (module);
587
588
/* reparent time manager window if visible */
589
if (GTK_SAT_MODULE (module)->tmgActive) {
590
gtk_window_set_transient_for (GTK_WINDOW (GTK_SAT_MODULE (module)->tmgWin),
591
GTK_WINDOW (app));
592
}
593
594
/* remove module from window, destroy window */
595
gtk_container_remove (GTK_CONTAINER (GTK_SAT_MODULE (module)->win), module);
596
gtk_widget_destroy (GTK_SAT_MODULE (module)->win);
597
GTK_SAT_MODULE (module)->win = NULL;
598
599
/* dock into mod-mgr */
600
mod_mgr_dock_module (module);
601
602
/* change internal state */
603
GTK_SAT_MODULE (module)->state = GTK_SAT_MOD_STATE_DOCKED;
640
604
641
605
/* store new state in configuration */
642
606
g_key_file_set_integer (GTK_SAT_MODULE (module)->cfgdata,
643
MOD_CFG_GLOBAL_SECTION,
644
MOD_CFG_STATE,
645
GTK_SAT_MOD_STATE_DOCKED);
646
647
/* decrease reference count of module */
648
g_object_unref (module);
649
650
651
break;
607
MOD_CFG_GLOBAL_SECTION,
608
MOD_CFG_STATE,
609
GTK_SAT_MOD_STATE_DOCKED);
610
611
/* decrease reference count of module */
612
g_object_unref (module);
613
614
615
break;
652
616
653
617
default:
654
618
655
sat_log_log (SAT_LOG_LEVEL_BUG,
656
_("%s:%d: Unknown module state: %d"),
657
__FILE__, __LINE__, GTK_SAT_MODULE (module)->state);
658
break;
619
sat_log_log (SAT_LOG_LEVEL_BUG,
620
_("%s:%d: Unknown module state: %d"),
621
__FILE__, __LINE__, GTK_SAT_MODULE (module)->state);
622
break;
659
623
660
}
624
}
661
625
662
626
663
627
}
669
633
* This function is intended to toggle between FULLSCREEN
670
634
* and WINDOW state.
671
635
*/
672
static void
673
screen_state_cb (GtkWidget *menuitem, gpointer data)
636
static void screen_state_cb (GtkWidget *menuitem, gpointer data)
674
637
{
675
GtkWidget *module = GTK_WIDGET (data);
638
GtkWidget *module = GTK_WIDGET (data);
676
639
gint w,h;
677
gchar *icon; /* icon file name */
678
gchar *title; /* window title */
679
680
681
switch (GTK_SAT_MODULE (module)->state) {
682
683
case GTK_SAT_MOD_STATE_DOCKED:
684
685
/* increase reference count of module */
686
g_object_ref (module);
687
688
/* we don't need the positions */
689
GTK_SAT_MODULE (module)->vpanedpos = -1;
690
GTK_SAT_MODULE (module)->hpanedpos = -1;
691
692
/* undock from mod-mgr */
693
mod_mgr_undock_module (module);
694
695
/* create window */
696
GTK_SAT_MODULE (module)->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
697
title = g_strconcat ("GPREDICT: ",
698
GTK_SAT_MODULE (module)->name,
699
" (", GTK_SAT_MODULE (module)->qth->name, ")",
700
NULL);
701
gtk_window_set_title (GTK_WINDOW (GTK_SAT_MODULE (module)->win), title);
702
g_free (title);
703
704
/* window icon */
705
icon = icon_file_name ("gpredict-icon.png");
706
if (g_file_test (icon, G_FILE_TEST_EXISTS)) {
707
gtk_window_set_icon_from_file (GTK_WINDOW (GTK_SAT_MODULE (module)->win), icon, NULL);
708
}
709
g_free (icon);
710
711
/* add module to window */
712
gtk_container_add (GTK_CONTAINER (GTK_SAT_MODULE (module)->win), module);
713
714
/* change internal state */
715
GTK_SAT_MODULE (module)->state = GTK_SAT_MOD_STATE_FULLSCREEN;
716
717
/* decrease reference count of module */
718
g_object_unref (module);
719
720
gtk_window_fullscreen (GTK_WINDOW (GTK_SAT_MODULE (module)->win));
721
722
/* show window */
723
gtk_widget_show_all (GTK_SAT_MODULE (module)->win);
640
gchar *icon; /* icon file name */
641
gchar *title; /* window title */
642
643
644
switch (GTK_SAT_MODULE (module)->state) {
645
646
case GTK_SAT_MOD_STATE_DOCKED:
647
648
/* increase reference count of module */
649
g_object_ref (module);
650
651
/* undock from mod-mgr */
652
mod_mgr_undock_module (module);
653
654
/* create window */
655
GTK_SAT_MODULE (module)->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
656
title = g_strconcat ("GPREDICT: ",
657
GTK_SAT_MODULE (module)->name,
658
" (", GTK_SAT_MODULE (module)->qth->name, ")",
659
NULL);
660
gtk_window_set_title (GTK_WINDOW (GTK_SAT_MODULE (module)->win), title);
661
g_free (title);
662
663
/* window icon */
664
icon = icon_file_name ("gpredict-icon.png");
665
if (g_file_test (icon, G_FILE_TEST_EXISTS)) {
666
gtk_window_set_icon_from_file (GTK_WINDOW (GTK_SAT_MODULE (module)->win), icon, NULL);
667
}
668
g_free (icon);
669
670
/* add module to window */
671
gtk_container_add (GTK_CONTAINER (GTK_SAT_MODULE (module)->win), module);
672
673
/* change internal state */
674
GTK_SAT_MODULE (module)->state = GTK_SAT_MOD_STATE_FULLSCREEN;
675
676
/* decrease reference count of module */
677
g_object_unref (module);
678
679
gtk_window_fullscreen (GTK_WINDOW (GTK_SAT_MODULE (module)->win));
680
681
/* show window */
682
gtk_widget_show_all (GTK_SAT_MODULE (module)->win);
724
683
725
/* reparent time manager window if visible */
726
if (GTK_SAT_MODULE (module)->tmgActive) {
727
gtk_window_set_transient_for (GTK_WINDOW (GTK_SAT_MODULE (module)->tmgWin),
728
GTK_WINDOW (GTK_SAT_MODULE (module)->win));
729
}
684
/* reparent time manager window if visible */
685
if (GTK_SAT_MODULE (module)->tmgActive) {
686
gtk_window_set_transient_for (GTK_WINDOW (GTK_SAT_MODULE (module)->tmgWin),
687
GTK_WINDOW (GTK_SAT_MODULE (module)->win));
688
}
730
689
731
break;
690
break;
732
691
733
692
734
693
case GTK_SAT_MOD_STATE_WINDOW:
735
736
/* we don't need the positions */
737
GTK_SAT_MODULE (module)->vpanedpos = -1;
738
GTK_SAT_MODULE (module)->hpanedpos = -1;
739
740
/* change internal state */
741
GTK_SAT_MODULE (module)->state = GTK_SAT_MOD_STATE_FULLSCREEN;
742
gtk_window_fullscreen (GTK_WINDOW (GTK_SAT_MODULE (module)->win));
743
gtk_window_set_default_size (GTK_WINDOW (GTK_SAT_MODULE (module)->win), 800, 600);
744
745
break;
694
/* change internal state */
695
GTK_SAT_MODULE (module)->state = GTK_SAT_MOD_STATE_FULLSCREEN;
696
gtk_window_fullscreen (GTK_WINDOW (GTK_SAT_MODULE (module)->win));
697
gtk_window_set_default_size (GTK_WINDOW (GTK_SAT_MODULE (module)->win), 800, 600);
698
699
break;
746
700
747
701
748
702
case GTK_SAT_MOD_STATE_FULLSCREEN:
749
750
/* store paned positions */
751
if (GTK_SAT_MODULE (module)->layout == GTK_SAT_MOD_LAYOUT_2) {
752
GTK_SAT_MODULE (module)->vpanedpos = gtk_paned_get_position (GTK_PANED (GTK_SAT_MODULE (module)->vpaned));
753
}
754
else if ((GTK_SAT_MODULE (module)->layout == GTK_SAT_MOD_LAYOUT_3) ||
755
(GTK_SAT_MODULE (module)->layout == GTK_SAT_MOD_LAYOUT_4)) {
756
757
GTK_SAT_MODULE (module)->vpanedpos = gtk_paned_get_position (GTK_PANED (GTK_SAT_MODULE (module)->vpaned));
758
GTK_SAT_MODULE (module)->hpanedpos = gtk_paned_get_position (GTK_PANED (GTK_SAT_MODULE (module)->hpaned));
759
}
760
761
/* change internal state */
762
GTK_SAT_MODULE (module)->state = GTK_SAT_MOD_STATE_WINDOW;
703
/* change internal state */
704
GTK_SAT_MODULE (module)->state = GTK_SAT_MOD_STATE_WINDOW;
763
705
gtk_window_unfullscreen (GTK_WINDOW (GTK_SAT_MODULE (module)->win));
764
706
765
707
/* get stored size; use some standard size if not explicitly specified */
781
723
if (sat_cfg_get_bool (SAT_CFG_BOOL_MOD_WIN_POS) &&
782
724
g_key_file_has_key (GTK_SAT_MODULE (module)->cfgdata, MOD_CFG_GLOBAL_SECTION, MOD_CFG_WIN_POS_X, NULL) &&
783
725
g_key_file_has_key (GTK_SAT_MODULE (module)->cfgdata, MOD_CFG_GLOBAL_SECTION, MOD_CFG_WIN_POS_Y, NULL)) {
784
726
785
727
gtk_window_move (GTK_WINDOW (GTK_SAT_MODULE (module)->win),
786
728
g_key_file_get_integer (GTK_SAT_MODULE (module)->cfgdata, MOD_CFG_GLOBAL_SECTION, MOD_CFG_WIN_POS_X, NULL),
787
g_key_file_get_integer (GTK_SAT_MODULE (module)->cfgdata, MOD_CFG_GLOBAL_SECTION, MOD_CFG_WIN_POS_Y, NULL));
729
g_key_file_get_integer (GTK_SAT_MODULE (module)->cfgdata, MOD_CFG_GLOBAL_SECTION, MOD_CFG_WIN_POS_Y, NULL));
788
730
789
}
731
}
790
732
791
733
/* store new state in configuration */
792
734
g_key_file_set_integer (GTK_SAT_MODULE (module)->cfgdata, MOD_CFG_GLOBAL_SECTION, MOD_CFG_STATE, GTK_SAT_MOD_STATE_WINDOW);
793
735
794
break;
736
break;
795
737
796
738
default:
797
739
798
sat_log_log (SAT_LOG_LEVEL_BUG,
799
_("%s:%d: Unknown module state: %d"),
800
__FILE__, __LINE__, GTK_SAT_MODULE (module)->state);
801
break;
740
sat_log_log (SAT_LOG_LEVEL_BUG,
741
_("%s:%d: Unknown module state: %d"),
742
__FILE__, __LINE__, GTK_SAT_MODULE (module)->state);
743
break;
802
744
803
}
745
}
804
746
805
747
}
806
748
811
753
* in that it will make the predictions with the satellites
812
754
* tracked in the current module.
813
755
*/
814
static void
815
sky_at_glance_cb (GtkWidget *menuitem, gpointer data)
756
static void sky_at_glance_cb (GtkWidget *menuitem, gpointer data)
816
757
{
817
GtkSatModule *module = GTK_SAT_MODULE (data);
818
GtkWidget *skg;
819
GtkWidget *window;
820
gchar *buff;
821
822
823
/* create window */
824
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
825
buff = g_strdup_printf (_("The sky at a glance (%s)"), module->name);
826
gtk_window_set_title (GTK_WINDOW (window), buff);
827
g_free (buff);
828
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (window_delete), NULL);
829
830
/* window icon */
831
buff = icon_file_name ("gpredict-planner.png");
832
gtk_window_set_icon_from_file (GTK_WINDOW (window), buff, NULL);
833
g_free (buff);
834
835
/* if module is busy wait until done then go on */
836
while (module->busy)
837
g_usleep (1000);
838
839
/* create sky at a glance widget */
840
module->busy = TRUE;
758
GtkSatModule *module = GTK_SAT_MODULE (data);
759
GtkWidget *skg;
760
GtkWidget *window;
761
gchar *buff;
762
763
764
/* create window */
765
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
766
buff = g_strdup_printf (_("The sky at a glance (%s)"), module->name);
767
gtk_window_set_title (GTK_WINDOW (window), buff);
768
g_free (buff);
769
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (window_delete), NULL);
770
771
/* window icon */
772
buff = icon_file_name ("gpredict-planner.png");
773
gtk_window_set_icon_from_file (GTK_WINDOW (window), buff, NULL);
774
g_free (buff);
775
776
/* if module is busy wait until done then go on */
777
g_mutex_lock(module->busy);
778
779
/* create sky at a glance widget */
841
780
842
781
if (sat_cfg_get_bool (SAT_CFG_BOOL_PRED_USE_REAL_T0)) {
843
782
skg = gtk_sky_glance_new (module->satellites, module->qth, 0.0);
846
785
skg = gtk_sky_glance_new (module->satellites, module->qth, module->tmgCdnum);
847
786
}
848
787
849
module->busy = FALSE;
850
851
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
852
gtk_container_add (GTK_CONTAINER (window), skg);
853
854
gtk_widget_show_all (window);
788
g_mutex_unlock(module->busy);
789
790
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
791
gtk_container_add (GTK_CONTAINER (window), skg);
792
793
gtk_widget_show_all (window);
855
794
856
795
}
857
796
858
797
/** \brief Open time manager. */
859
static void
860
tmgr_cb (GtkWidget *menuitem, gpointer data)
798
static void tmgr_cb (GtkWidget *menuitem, gpointer data)
861
799
{
862
GtkSatModule *module = GTK_SAT_MODULE (data);
800
GtkSatModule *module = GTK_SAT_MODULE (data);
863
801
864
tmg_create (module);
802
tmg_create (module);
865
803
}
866
804
867
805
/** \brief Open Radio control window.
868
806
* \param menuitem The menuitem that was selected.
869
807
* \param data Pointer the GtkSatModule.
870
808
*/
871
static void
872
rigctrl_cb (GtkWidget *menuitem, gpointer data)
809
static void rigctrl_cb (GtkWidget *menuitem, gpointer data)
873
810
{
874
811
GtkSatModule *module = GTK_SAT_MODULE (data);
875
812
gchar *buff;
890
827
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
891
828
_("You have no radio configuration!\n"\
892
829
"Please configure a radio first.")
893
);
830
);
894
831
g_signal_connect_swapped (dialog, "response",
895
832
G_CALLBACK (gtk_widget_destroy), dialog);
896
833
gtk_window_set_title (GTK_WINDOW (dialog), _("ERROR"));
927
864
*
928
865
* This function is called automatically when the window is destroyed.
929
866
*/
930
static void
931
destroy_rigctrl (GtkWidget *window, gpointer data)
867
static void destroy_rigctrl (GtkWidget *window, gpointer data)
932
868
{
933
869
GtkSatModule *module = GTK_SAT_MODULE (data);
934
870
941
877
* \param menuitem The menuitem that was selected.
942
878
* \param data Pointer the GtkSatModule.
943
879
*/
944
static void
945
rotctrl_cb (GtkWidget *menuitem, gpointer data)
880
static void rotctrl_cb (GtkWidget *menuitem, gpointer data)
946
881
{
947
882
GtkSatModule *module = GTK_SAT_MODULE (data);
948
883
gchar *buff;
963
898
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
964
899
_("You have no rotator configuration!\n"\
965
900
"Please configure an antenna rotator first.")
966
);
901
);
967
902
g_signal_connect_swapped (dialog, "response",
968
903
G_CALLBACK (gtk_widget_destroy), dialog);
969
904
gtk_window_set_title (GTK_WINDOW (dialog), _("ERROR"));
999
934
*
1000
935
* This function is called automatically when the window is destroyed.
1001
936
*/
1002
static void
1003
destroy_rotctrl (GtkWidget *window, gpointer data)
937
static void destroy_rotctrl (GtkWidget *window, gpointer data)
1004
938
{
1005
939
GtkSatModule *module = GTK_SAT_MODULE (data);
1006
940
1009
943
}
1010
944
1011
945
/* ensure that deleted top-level windows are destroyed */
1012
static gint
1013
window_delete (GtkWidget *widget,
1014
GdkEvent *event,
1015
gpointer data)
946
static gint window_delete (GtkWidget *widget,
947
GdkEvent *event,
948
gpointer data)
1016
949
{
1017
950
return FALSE;
1018
951
}
1025
958
* item in the GtkSatModule popup menu. It is simply a wrapper
1026
959
* for gtk_sat_module_close_cb, which will close the current module.
1027
960
*/
1028
static void
1029
close_cb (GtkWidget *menuitem, gpointer data)
961
static void close_cb (GtkWidget *menuitem, gpointer data)
1030
962
{
1031
gtk_sat_module_close_cb (menuitem, data);
963
gtk_sat_module_close_cb (menuitem, data);
1032
964
}
1033
965
1034
966
/** \brief Close and permanently delete module.
1038
970
* with gtk_sat_module_close_cb, which will close the current module,
1039
971
* whereafter the module file will be deleted from the disk.
1040
972
*/
1041
static void
1042
delete_cb (GtkWidget *menuitem, gpointer data)
973
static void delete_cb (GtkWidget *menuitem, gpointer data)
1043
974
{
1044
gchar *file;
1045
GtkWidget *dialog;
1046
gchar *moddir;
1047
1048
moddir = get_modules_dir ();
1049
file = g_strconcat (moddir, G_DIR_SEPARATOR_S,
1050
GTK_SAT_MODULE (data)->name, ".mod", NULL);
1051
g_free (moddir);
1052
1053
gtk_sat_module_close_cb (menuitem, data);
1054
1055
1056
/* ask user to confirm removal */
1057
dialog = gtk_message_dialog_new_with_markup
1058
(NULL, //GTK_WINDOW (parent),
1059
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1060
GTK_MESSAGE_QUESTION,
1061
GTK_BUTTONS_YES_NO,
1062
_("This operation will permanently delete\n<b>%s</b>\n"\
1063
"from the disk.\nDo you you want to proceed?"),
1064
file);
1065
1066
switch (gtk_dialog_run (GTK_DIALOG (dialog))) {
1067
1068
case GTK_RESPONSE_YES:
1069
1070
if (g_remove (file)) {
1071
sat_log_log (SAT_LOG_LEVEL_ERROR,
1072
_("%s:%d: Failed to delete %s."),
1073
__FILE__, __LINE__, file);
1074
}
1075
else {
1076
sat_log_log (SAT_LOG_LEVEL_ERROR,
1077
_("%s:%d: %s deleted permanently."),
1078
__FILE__, __LINE__, file);
1079
}
1080
break;
975
gchar *file;
976
GtkWidget *dialog;
977
gchar *moddir;
978
979
moddir = get_modules_dir ();
980
file = g_strconcat (moddir, G_DIR_SEPARATOR_S,
981
GTK_SAT_MODULE (data)->name, ".mod", NULL);
982
g_free (moddir);
983
984
gtk_sat_module_close_cb (menuitem, data);
985
986
987
/* ask user to confirm removal */
988
dialog = gtk_message_dialog_new_with_markup
989
(NULL, //GTK_WINDOW (parent),
990
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
991
GTK_MESSAGE_QUESTION,
992
GTK_BUTTONS_YES_NO,
993
_("This operation will permanently delete\n<b>%s</b>\n"\
994
"from the disk.\nDo you you want to proceed?"),
995
file);
996
997
switch (gtk_dialog_run (GTK_DIALOG (dialog))) {
998
999
case GTK_RESPONSE_YES:
1000
1001
if (g_remove (file)) {
1002
sat_log_log (SAT_LOG_LEVEL_ERROR,
1003
_("%s:%d: Failed to delete %s."),
1004
__FILE__, __LINE__, file);
1005
}
1006
else {
1007
sat_log_log (SAT_LOG_LEVEL_ERROR,
1008
_("%s:%d: %s deleted permanently."),
1009
__FILE__, __LINE__, file);
1010
}
1011
break;
1081
1012
1082
1013
default:
1083
break;
1084
}
1085
1086
gtk_widget_destroy (dialog);
1087
1088
g_free (file);
1014
break;
1015
}
1016
1017
gtk_widget_destroy (dialog);
1018
1019
g_free (file);
1089
1020
}
1090
1021
1091
1022
1095
1026
* The primary purpose of this function is to check whether the char length
1096
1027
* of the name is greater than zero, if yes enable the OK button of the dialog.
1097
1028
*/
1098
static void
1099
name_changed (GtkWidget *widget, gpointer data)
1029
static void name_changed (GtkWidget *widget, gpointer data)
1100
1030
{
1101
const gchar *text;
1102
gchar *entry, *end, *j;
1103
gint len, pos;
1104
GtkWidget *dialog = GTK_WIDGET (data);
1105
1106
1107
/* step 1: ensure that only valid characters are entered
1031
const gchar *text;
1032
gchar *entry, *end, *j;
1033
gint len, pos;
1034
GtkWidget *dialog = GTK_WIDGET (data);
1035
1036
1037
/* step 1: ensure that only valid characters are entered
1108
1038
(stolen from xlog, tnx pg4i)
1109
1039
*/
1110
entry = gtk_editable_get_chars (GTK_EDITABLE (widget), 0, -1);
1111
if ((len = g_utf8_strlen (entry, -1)) > 0)
1112
{
1113
end = entry + g_utf8_strlen (entry, -1);
1114
for (j = entry; j < end; ++j)
1115
{
1116
switch (*j)
1117
{
1118
case '0' ... '9':
1119
case 'a' ... 'z':
1120
case 'A' ... 'Z':
1121
case '-':
1122
case '_':
1123
break;
1124
default:
1125
gdk_beep ();
1126
pos = gtk_editable_get_position (GTK_EDITABLE (widget));
1127
gtk_editable_delete_text (GTK_EDITABLE (widget),
1128
pos, pos+1);
1129
break;
1130
}
1131
}
1132
}
1133
1134
1135
/* step 2: if name seems all right, enable OK button */
1136
text = gtk_entry_get_text (GTK_ENTRY (widget));
1137
1138
if (g_utf8_strlen (text, -1) > 0) {
1139
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
1140
GTK_RESPONSE_OK,
1141
TRUE);
1142
}
1143
else {
1144
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
1145
GTK_RESPONSE_OK,
1146
FALSE);
1147
}
1040
entry = gtk_editable_get_chars (GTK_EDITABLE (widget), 0, -1);
1041
if ((len = g_utf8_strlen (entry, -1)) > 0)
1042
{
1043
end = entry + g_utf8_strlen (entry, -1);
1044
for (j = entry; j < end; ++j)
1045
{
1046
switch (*j)
1047
{
1048
case '0' ... '9':
1049
case 'a' ... 'z':
1050
case 'A' ... 'Z':
1051
case '-':
1052
case '_':
1053
break;
1054
default:
1055
gdk_beep ();
1056
pos = gtk_editable_get_position (GTK_EDITABLE (widget));
1057
gtk_editable_delete_text (GTK_EDITABLE (widget),
1058
pos, pos+1);
1059
break;
1060
}
1061
}
1062
}
1063
1064
1065
/* step 2: if name seems all right, enable OK button */
1066
text = gtk_entry_get_text (GTK_ENTRY (widget));
1067
1068
if (g_utf8_strlen (text, -1) > 0) {
1069
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
1070
GTK_RESPONSE_OK,
1071
TRUE);
1072
}
1073
else {
1074
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
1075
GTK_RESPONSE_OK,
1076
FALSE);
1077
}
1148
1078
}
1149
1079
1150
1080
1166
1096
* \note The logic in the code has been borrowed from gaim/pidgin http://pidgin.im/
1167
1097
*
1168
1098
*/
1169
gboolean
1170
module_window_config_cb (GtkWidget *widget, GdkEventConfigure *event, gpointer data)
1099
gboolean module_window_config_cb (GtkWidget *widget, GdkEventConfigure *event, gpointer data)
1171
1100
{
1172
1101
gint x, y;
1173
1102
GtkSatModule *module = GTK_SAT_MODULE (data);
1178
1107
gtk_window_get_position (GTK_WINDOW (widget), &x, &y);
1179
1108
else
1180
1109
return FALSE; /* carry on normally */
1181
1110
1182
1111
#ifdef G_OS_WIN32
1183
1112
/* Workaround for GTK+ bug # 169811 - "configure_event" is fired
1184
1113
when the window is being maximized */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1