1 /*
2 * xnec2c - GTK2-based version of nec2c, the C translation of NEC2
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19 #ifdef HAVE_CONFIG_H
20 # include <config.h>
21 #endif
22
23 #include <gtk/gtk.h>
24
25 #include "callbacks.h"
26 #include "interface.h"
27 #include "support.h"
28 #include "fork.h"
29 #include "xnec2c.h"
30 #include "editors.h"
31 #include "nec2_model.h"
32 #include "shared.h"
33 #include <gdk/gdkkeysyms.h>
34
35 /* File chooser/select widgets */
36 static GtkWidget *file_chooser = NULL;
37 static GtkWidget *file_selection = NULL;
38
39 /* Tree view clicked on by user */
40 static GtkTreeView *selected_treeview = NULL;
41
42 /* Pixmap for saving drawable images */
43 static GdkPixmap *saveas_pixmap = NULL;
44 static int saveas_pixmap_width, saveas_pixmap_height;
45
46 /* Action flag for NEC2 "card" editors */
47 static int action = EDITOR_NEW;
48
49 /*-----------------------------------------------------------------------*/
50
51 void
on_main_window_destroy(GtkObject * object,gpointer user_data)52 on_main_window_destroy (GtkObject *object,
53 gpointer user_data)
54 {
55 Gtk_Quit();
56 }
57
58
59 gboolean
on_main_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)60 on_main_window_delete_event (GtkWidget *widget,
61 GdkEvent *event,
62 gpointer user_data)
63 {
64 kill_window = main_window;
65 SetFlag( MAIN_QUIT );
66 Delete_Event( _("Really quit xnec2c?") );
67 return TRUE;
68 }
69
70
71 void
on_new_activate(GtkMenuItem * menuitem,gpointer user_data)72 on_new_activate (GtkMenuItem *menuitem,
73 gpointer user_data)
74 {
75 /* No save/open file while freq loop is running */
76 if( !Nec2_Save_Warn(
77 _("A new NEC2 input file may not be created\n"\
78 "while the Frequency Loop is running") ) )
79 return;
80
81 /* Save open file, if any */
82 if( (input_fp != NULL) && (nec2_edit_window != NULL) )
83 {
84 stop( _("Saving already open NEC2 file\n"\
85 "before opening new default file"), ERR_OK );
86 Save_Nec2_Input_File( nec2_edit_window, infile );
87 infile[0] = '\0';
88 }
89
90 /* Open editor window if needed */
91 if( nec2_edit_window == NULL )
92 {
93 Close_File( &input_fp );
94 infile[0] = '\0';
95 Open_Nec2_Editor( NEC2_EDITOR_NEW );
96 }
97 else Nec2_Input_File_Treeview( NEC2_EDITOR_NEW );
98 }
99
100
101 void
on_open_input_activate(GtkMenuItem * menuitem,gpointer user_data)102 on_open_input_activate (GtkMenuItem *menuitem,
103 gpointer user_data)
104 {
105 /* No save/open file while freq loop is running */
106 if( !Nec2_Save_Warn(
107 _("A new NEC2 input file may not be opened\n"\
108 "while the Frequency Loop is running")) )
109 return;
110
111 /* Open file chooser to select a NEC2 input file */
112 file_chooser = create_filechooserdialog();
113 gtk_widget_show( file_chooser );
114
115 /* Set filechooser file name to previously selected, if any */
116 if( (strlen(infile) != 0) && (infile[0] == '/') )
117 gtk_file_chooser_set_filename(
118 GTK_FILE_CHOOSER(file_chooser), infile );
119 }
120
121
122 void
on_main_save_activate(GtkMenuItem * menuitem,gpointer user_data)123 on_main_save_activate (GtkMenuItem *menuitem,
124 gpointer user_data)
125 {
126 char saveas[96];
127 size_t s = sizeof( saveas );
128
129 /* Count number of structure image files saved of geometry,
130 * currents or charges, to avoid over-writing saved files */
131 static int cgm = 0, ccr = 0, cch = 0;
132
133 if( strlen(infile) == 0 )
134 return;
135
136 /* Make the structure image save file name from input file
137 * name. The count of each image type saved is incremented */
138 if( isFlagSet(DRAW_CURRENTS) )
139 snprintf( saveas, s, "%s-%s_%03d.%s", infile, "current", ++ccr, "png" );
140 else if( isFlagSet(DRAW_CHARGES) )
141 snprintf( saveas, s, "%s-%s_%03d.%s", infile, "charge", ++cch, "png" );
142 else
143 snprintf( saveas, s, "%s-%s_%03d.%s", infile, "geometry", ++cgm, "png" );
144
145 saveas_pixmap = structure_pixmap;
146 saveas_pixmap_width = structure_pixmap_width;
147 saveas_pixmap_height = structure_pixmap_height;
148 ClearFlag( ALL_SAVE_FLAGS );
149 SetFlag( IMAGE_SAVE );
150
151 /* Open file selector to specify file */
152 /* name for saving the structure image */
153 file_selection = create_fileselection();
154 gtk_file_selection_set_filename( GTK_FILE_SELECTION(file_selection), saveas );
155 gtk_widget_show( file_selection );
156 }
157
158
159 void
on_main_save_as_activate(GtkMenuItem * menuitem,gpointer user_data)160 on_main_save_as_activate (GtkMenuItem *menuitem,
161 gpointer user_data)
162 {
163 saveas_pixmap = structure_pixmap;
164 saveas_pixmap_width = structure_pixmap_width;
165 saveas_pixmap_height = structure_pixmap_height;
166 ClearFlag( ALL_SAVE_FLAGS );
167 SetFlag( IMAGE_SAVE );
168
169 /* Open file selector to specify file */
170 /* name for saving the structure image */
171 file_selection = create_fileselection();
172 gtk_widget_show( file_selection );
173 }
174
175
176 void
on_struct_save_as_gnuplot_activate(GtkMenuItem * menuitem,gpointer user_data)177 on_struct_save_as_gnuplot_activate (GtkMenuItem *menuitem,
178 gpointer user_data)
179 {
180 /* Open file selector to specify a file
181 * name for saving the rad pattern image */
182 ClearFlag( ALL_SAVE_FLAGS );
183 SetFlag( STRCT_GNUPLOT_SAVE );
184 file_selection = create_fileselection();
185 gtk_widget_show( file_selection );
186 }
187
188
189 void
on_quit_activate(GtkMenuItem * menuitem,gpointer user_data)190 on_quit_activate (GtkMenuItem *menuitem,
191 gpointer user_data)
192 {
193 kill_window = main_window;
194 SetFlag( MAIN_QUIT );
195 Delete_Event( _("Really quit xnec2c?") );
196 }
197
198
199 void
on_main_rdpattern_activate(GtkMenuItem * menuitem,gpointer user_data)200 on_main_rdpattern_activate (GtkMenuItem *menuitem,
201 gpointer user_data)
202 {
203 /* Open radiation pattern rendering window */
204 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
205 {
206 rdpattern_window = create_rdpattern_window();
207 gtk_widget_show( rdpattern_window );
208 rdpattern_drawingarea = lookup_widget(
209 rdpattern_window, "rdpattern_drawingarea" );
210 rdpattern_motion_handler = g_signal_connect (
211 (gpointer) rdpattern_drawingarea,
212 "motion_notify_event",
213 G_CALLBACK (on_rdpattern_drawingarea_motion_notify_event),
214 NULL);
215 gtk_widget_add_events(
216 GTK_WIDGET(rdpattern_drawingarea),
217 GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK );
218 rotate_rdpattern = GTK_SPIN_BUTTON(lookup_widget(
219 rdpattern_window, "rdpattern_rotate_spinbutton"));
220 incline_rdpattern = GTK_SPIN_BUTTON(lookup_widget(
221 rdpattern_window, "rdpattern_incline_spinbutton"));
222 rdpattern_frequency = GTK_SPIN_BUTTON(lookup_widget(
223 rdpattern_window, "rdpattern_freq_spinbutton"));
224 rdpattern_zoom = GTK_SPIN_BUTTON(lookup_widget(
225 rdpattern_window, "rdpattern_zoom_spinbutton"));
226 rdpattern_fstep_entry = GTK_ENTRY(lookup_widget(
227 rdpattern_window, "rdpattern_fstep_entry")) ;
228
229 Main_Rdpattern_Activate( TRUE );
230 }
231 else if( isFlagSet(DRAW_ENABLED) )
232 gtk_widget_destroy( rdpattern_window );
233 }
234
235
236 void
on_main_freqplots_activate(GtkMenuItem * menuitem,gpointer user_data)237 on_main_freqplots_activate (GtkMenuItem *menuitem,
238 gpointer user_data)
239 {
240 /* Open window for plotting frequency
241 * related data (gain, vswr etc) */
242 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
243 {
244 if( Main_Freqplots_Activate() )
245 {
246 freqplots_window = create_freqplots_window();
247 gtk_widget_show( freqplots_window );
248 freqplots_drawingarea = lookup_widget(
249 freqplots_window, "freqplots_drawingarea" );
250 Set_Window_Labels();
251 calc_data.ngraph = 0;
252 } /* if( Main_Freqplots_Activate() */
253 else gtk_check_menu_item_set_active(
254 GTK_CHECK_MENU_ITEM(menuitem), FALSE );
255 }
256 else if( isFlagSet(PLOT_ENABLED) )
257 gtk_widget_destroy( freqplots_window );
258 }
259
260
261 void
on_rdpattern_total_activate(GtkMenuItem * menuitem,gpointer user_data)262 on_rdpattern_total_activate (GtkMenuItem *menuitem,
263 gpointer user_data)
264 {
265 Set_Polarization( POL_TOTAL );
266 }
267
268
269 void
on_rdpattern_horizontal_activate(GtkMenuItem * menuitem,gpointer user_data)270 on_rdpattern_horizontal_activate (GtkMenuItem *menuitem,
271 gpointer user_data)
272 {
273 Set_Polarization( POL_HORIZ );
274 }
275
276
277 void
on_rdpattern_vertical_activate(GtkMenuItem * menuitem,gpointer user_data)278 on_rdpattern_vertical_activate (GtkMenuItem *menuitem,
279 gpointer user_data)
280 {
281 Set_Polarization( POL_VERT );
282 }
283
284
285 void
on_rdpattern_right_hand_activate(GtkMenuItem * menuitem,gpointer user_data)286 on_rdpattern_right_hand_activate (GtkMenuItem *menuitem,
287 gpointer user_data)
288 {
289 Set_Polarization( POL_RHCP );
290 }
291
292
293 void
on_rdpattern_left_hand_activate(GtkMenuItem * menuitem,gpointer user_data)294 on_rdpattern_left_hand_activate (GtkMenuItem *menuitem,
295 gpointer user_data)
296 {
297 Set_Polarization( POL_LHCP );
298 }
299
300
301 void
on_common_projection_activate(GtkMenuItem * menuitem,gpointer user_data)302 on_common_projection_activate (GtkMenuItem *menuitem,
303 gpointer user_data)
304 {
305 /* Enable syncing of projection params
306 * for structure and rad pattern drawing */
307 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
308 {
309 if( isFlagSet(DRAW_ENABLED) )
310 {
311 rdpattern_proj_params.Wr = structure_proj_params.Wr;
312 rdpattern_proj_params.Wi = structure_proj_params.Wi;
313 New_Viewer_Angle(
314 rdpattern_proj_params.Wr,
315 rdpattern_proj_params.Wi,
316 rotate_rdpattern,
317 incline_rdpattern,
318 &rdpattern_proj_params );
319 }
320 SetFlag( COMMON_PROJECTION );
321 }
322 else
323 ClearFlag( COMMON_PROJECTION );
324 }
325
326
327 void
on_common_freq_activate(GtkMenuItem * menuitem,gpointer user_data)328 on_common_freq_activate (GtkMenuItem *menuitem,
329 gpointer user_data)
330 {
331 /* Enable syncing of frequency spinbuttons
332 * between main and rad pattern windows */
333 if( gtk_check_menu_item_get_active(
334 GTK_CHECK_MENU_ITEM(menuitem)) )
335 SetFlag( COMMON_FREQUENCY );
336 else
337 ClearFlag( COMMON_FREQUENCY );
338 }
339
340
341 void
on_main_x_axis_clicked(GtkButton * button,gpointer user_data)342 on_main_x_axis_clicked (GtkButton *button,
343 gpointer user_data)
344 {
345 /* Recalculate projection paramenters */
346 New_Viewer_Angle( 0.0, 0.0, rotate_structure,
347 incline_structure, &structure_proj_params );
348 if( isFlagSet(DRAW_ENABLED) && isFlagSet(COMMON_PROJECTION) )
349 New_Viewer_Angle( 0.0, 0.0, rotate_rdpattern,
350 incline_rdpattern, &rdpattern_proj_params );
351 }
352
353
354 void
on_main_y_axis_clicked(GtkButton * button,gpointer user_data)355 on_main_y_axis_clicked (GtkButton *button,
356 gpointer user_data)
357 {
358 /* Recalculate projection paramenters */
359 New_Viewer_Angle( 90.0, 0.0, rotate_structure,
360 incline_structure, &structure_proj_params );
361 if( isFlagSet(DRAW_ENABLED) && isFlagSet(COMMON_PROJECTION) )
362 New_Viewer_Angle( 90.0, 0.0, rotate_rdpattern,
363 incline_rdpattern, &rdpattern_proj_params );
364 }
365
366
367 void
on_main_z_axis_clicked(GtkButton * button,gpointer user_data)368 on_main_z_axis_clicked (GtkButton *button,
369 gpointer user_data)
370 {
371 /* Recalculate projection paramenters */
372 New_Viewer_Angle( 0.0, 90.0, rotate_structure,
373 incline_structure, &structure_proj_params );
374 if( isFlagSet(DRAW_ENABLED) && isFlagSet(COMMON_PROJECTION) )
375 New_Viewer_Angle( 0.0, 90.0, rotate_rdpattern,
376 incline_rdpattern, &rdpattern_proj_params );
377 }
378
379
380 void
on_main_default_view_clicked(GtkButton * button,gpointer user_data)381 on_main_default_view_clicked (GtkButton *button,
382 gpointer user_data)
383 {
384 /* Projection at 45 deg rotation and inclination */
385 New_Viewer_Angle( 45.0, 45.0, rotate_structure,
386 incline_structure, &structure_proj_params );
387 if( isFlagSet(DRAW_ENABLED) && isFlagSet(COMMON_PROJECTION) )
388 New_Viewer_Angle( 45.0, 45.0, rotate_rdpattern,
389 incline_rdpattern, &rdpattern_proj_params );
390 }
391
392
393 void
on_main_rotate_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)394 on_main_rotate_spinbutton_value_changed(
395 GtkSpinButton *spinbutton,
396 gpointer user_data)
397 {
398 /* No redraws if new input pending */
399 if( isFlagSet(INPUT_PENDING) )
400 return;
401
402 /* Get new "rotate" structure angle from spinbutton */
403 structure_proj_params.Wr = gtk_spin_button_get_value(spinbutton);
404
405 /* Sync rad pattrern window spinbutton if enabled */
406 if( isFlagSet(DRAW_ENABLED) && isFlagSet(COMMON_PROJECTION) )
407 gtk_spin_button_set_value(
408 rotate_rdpattern, (gdouble)structure_proj_params.Wr );
409
410 New_Structure_Projection_Angle();
411 gtk_spin_button_update( spinbutton );
412 }
413
414
415 void
on_main_incline_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)416 on_main_incline_spinbutton_value_changed(
417 GtkSpinButton *spinbutton,
418 gpointer user_data)
419 {
420 /* No redraws if new input pending */
421 if( isFlagSet(INPUT_PENDING) )
422 return;
423
424 /* Get new "incline" structure angle from spinbutton */
425 structure_proj_params.Wi = gtk_spin_button_get_value(spinbutton);
426
427 /* Sync rad pattrern window spinbutton if enabled */
428 if( isFlagSet(DRAW_ENABLED) && isFlagSet(COMMON_PROJECTION) )
429 gtk_spin_button_set_value(
430 incline_rdpattern, (gdouble)structure_proj_params.Wi );
431
432 New_Structure_Projection_Angle();
433 gtk_spin_button_update( spinbutton );
434 }
435
436
437 void
on_main_currents_togglebutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)438 on_main_currents_togglebutton_toggled (GtkToggleButton *togglebutton,
439 gpointer user_data)
440 {
441 /* Enable calculation and rendering of structure curents */
442 Main_Currents_Togglebutton_Toggled(
443 gtk_toggle_button_get_active(togglebutton) );
444 }
445
446
447 void
on_main_charges_togglebutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)448 on_main_charges_togglebutton_toggled (GtkToggleButton *togglebutton,
449 gpointer user_data)
450 {
451 /* Enable calculation and rendering of structure charge density */
452 Main_Charges_Togglebutton_Toggled(
453 gtk_toggle_button_get_active(togglebutton) );
454 }
455
456
457 gboolean
on_main_colorcode_drawingarea_expose_event(GtkWidget * widget,GdkEventExpose * event,gpointer user_data)458 on_main_colorcode_drawingarea_expose_event( GtkWidget *widget,
459 GdkEventExpose *event,
460 gpointer user_data)
461 {
462 double red = 0.0, grn = 0.0, blu = 0.0;
463 int idx;
464
465 /* No redraws if new input pending */
466 if( isFlagSet(INPUT_PENDING) )
467 return FALSE;
468
469 cairo_t *cr = gdk_cairo_create( widget-> window );
470
471 /* Draw color-code bar in main window */
472 for( idx = 0; idx < 160; idx++ )
473 {
474 Value_to_Color( &red, &grn, &blu, (double) (8*idx), 1280.0 );
475 cairo_set_source_rgb( cr, red, grn, blu );
476 Cairo_Draw_Line( cr, idx, 0, idx, 28 );
477 }
478
479 cairo_destroy( cr );
480 return TRUE;
481 }
482
483
484 void
on_main_freq_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)485 on_main_freq_spinbutton_value_changed (GtkSpinButton *spinbutton,
486 gpointer user_data)
487 {
488 static gdouble fmhz_save = 0.0;
489
490 /* No redraws if new input pending */
491 if( isFlagSet(INPUT_PENDING) )
492 return;
493
494 /* Frequency spinbutton value changed by frequency loop */
495 if( isFlagSet(FREQ_LOOP_RUNNING) )
496 Draw_Structure( structure_drawingarea );
497 else /* by user */
498 {
499 /* Get freq from spin button, avoid double signal by GTK */
500 gdouble fmhz = (gdouble)gtk_spin_button_get_value(spinbutton);
501 if( (fmhz == fmhz_save) && isFlagClear(PLOT_FREQ_LINE) )
502 return; /* to avoid double signal by GTK */
503 fmhz_save = fmhz;
504
505 /* If new freq calculations are enabled by
506 * checkbutton next to freq spinbutton or
507 * freq line plotting enabled, redo currents */
508 if( isFlagSet(PLOT_FREQ_LINE) ||
509 (isFlagSet(MAIN_NEW_FREQ) &&
510 (isFlagSet(DRAW_CURRENTS) ||
511 isFlagSet(DRAW_CHARGES))) )
512
513 {
514 /* Recalc currents in structure */
515 calc_data.fmhz = (double)fmhz;
516 g_idle_add( Redo_Currents, NULL );
517 }
518
519 /* Sync rad pattern frequency spinbutton */
520 if( isFlagSet(DRAW_ENABLED) &&
521 isFlagSet(COMMON_FREQUENCY) &&
522 isFlagSet(MAIN_NEW_FREQ) )
523 /* Show current frequency */
524 gtk_spin_button_set_value( rdpattern_frequency, fmhz );
525
526 } /* else */
527
528 gtk_spin_button_update( spinbutton );
529 }
530
531
532 void
on_main_freq_checkbutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)533 on_main_freq_checkbutton_toggled (GtkToggleButton *togglebutton,
534 gpointer user_data)
535 {
536 if( gtk_toggle_button_get_active(togglebutton) )
537 SetFlag(MAIN_NEW_FREQ);
538 else
539 ClearFlag(MAIN_NEW_FREQ);
540 }
541
542
543 void
on_main_new_freq_clicked(GtkButton * button,gpointer user_data)544 on_main_new_freq_clicked (GtkButton *button,
545 gpointer user_data)
546 {
547 /* Recalculate (and redraw) currents on user command */
548 if( isFlagClear(FREQ_LOOP_RUNNING) )
549 {
550 calc_data.fmhz =
551 (double)gtk_spin_button_get_value( mainwin_frequency );
552 g_idle_add( Redo_Currents, NULL );
553 }
554 }
555
556
557 gboolean
on_structure_drawingarea_configure_event(GtkWidget * widget,GdkEventConfigure * event,gpointer user_data)558 on_structure_drawingarea_configure_event( GtkWidget *widget,
559 GdkEventConfigure *event,
560 gpointer user_data)
561 {
562 /* Create or resize structure drawing pixmap */
563 Create_Pixmap(
564 &structure_pixmap,
565 &structure_pixmap_width,
566 &structure_pixmap_height,
567 widget, event,
568 &structure_proj_params );
569 return TRUE;
570 }
571
572
573 gboolean
on_structure_drawingarea_motion_notify_event(GtkWidget * widget,GdkEventMotion * event,gpointer user_data)574 on_structure_drawingarea_motion_notify_event( GtkWidget *widget,
575 GdkEventMotion *event,
576 gpointer user_data)
577 {
578 /* Use only 1 in MOTION_EVENTS_COUNT event */
579 static int cnt = 0;
580 if( cnt++ < MOTION_EVENTS_COUNT )
581 return FALSE;
582 cnt = 0;
583
584 /* Block motion events */
585 g_signal_handler_block
586 ( (gpointer)structure_drawingarea, structure_motion_handler );
587
588 /* No redraws if new input pending */
589 if( isFlagSet(INPUT_PENDING) )
590 return FALSE;
591
592 /* Handle motion events */
593 Motion_Event( event, &structure_proj_params );
594
595 /* Unblock motion events */
596 g_signal_handler_unblock(
597 (gpointer)structure_drawingarea, structure_motion_handler );
598
599 return TRUE;
600 }
601
602
603 gboolean
on_structure_drawingarea_expose_event(GtkWidget * widget,GdkEventExpose * event,gpointer user_data)604 on_structure_drawingarea_expose_event (GtkWidget *widget,
605 GdkEventExpose *event,
606 gpointer user_data)
607 {
608 /* No redraws if new input pending */
609 if( isFlagSet(INPUT_PENDING) )
610 return FALSE;
611
612 Draw_Structure( widget );
613 return TRUE;
614 }
615
616
617 void
on_filechooserdialog_response(GtkDialog * dialog,gint response_id,gpointer user_data)618 on_filechooserdialog_response (GtkDialog *dialog,
619 gint response_id,
620 gpointer user_data)
621 {
622 if( response_id == GTK_RESPONSE_OK )
623 {
624 gchar *filename;
625 gboolean new = TRUE;
626
627 /* Save any changes to an open file */
628 Save_Nec2_Input_File( nec2_edit_window, infile );
629
630 /* Get filename of NEC2 input file */
631 filename =
632 gtk_file_chooser_get_filename( GTK_FILE_CHOOSER(dialog) );
633 Strlcpy( infile, filename, sizeof(infile) );
634 g_free( filename );
635 gtk_widget_destroy( file_chooser );
636
637 /* Open new file */
638 Open_Input_File( (gpointer)&new );
639 }
640 }
641
642
643 void
on_fileselection_response(GtkDialog * dialog,gint response_id,gpointer user_data)644 on_fileselection_response( GtkDialog *dialog,
645 gint response_id,
646 gpointer user_data)
647 {
648 gchar filename[81];
649 size_t s = sizeof( filename );
650 char *str;
651 gboolean new = FALSE;
652
653 /* User selects a file name to save a pixmap to file */
654 if( response_id == GTK_RESPONSE_OK )
655 {
656 /* Get the "save as" file name */
657 Strlcpy( filename,
658 gtk_file_selection_get_filename(
659 GTK_FILE_SELECTION(dialog)), s );
660
661 if( isFlagSet(IMAGE_SAVE) )
662 {
663 /* cat a file extension if not already there */
664 str = strstr( filename, ".png" );
665 if( (str == NULL) || (str[4] != '\0') )
666 Strlcat( filename, ".png", s );
667 Save_Pixmap(
668 saveas_pixmap, saveas_pixmap_width,
669 saveas_pixmap_height, filename );
670 }
671 else if( isFlagSet(NEC2_SAVE) )
672 {
673 /* cat a file extension if not already there */
674 str = strstr( filename, ".nec" );
675 if( (str == NULL) || (str[4] != '\0') )
676 Strlcat( filename, ".nec", s );
677
678 /* Use new file name as input file */
679 Strlcpy( infile, filename, sizeof(infile) );
680 Save_Nec2_Input_File( nec2_edit_window, filename );
681
682 /* Re-open NEC2 input file */
683 if( Nec2_Apply_Checkbutton() )
684 Open_Input_File( (gpointer)&new );
685 }
686 else if( isFlagSet(RDPAT_GNUPLOT_SAVE) )
687 {
688 /* cat a file extension if not already there */
689 str = strstr( filename, ".gplot" );
690 if( (str == NULL) || (str[6] != '\0') )
691 Strlcat( filename, ".gplot", s );
692 Save_RadPattern_Gnuplot_Data( filename );
693 }
694 else if( isFlagSet(PLOTS_GNUPLOT_SAVE) )
695 {
696 /* cat a file extension if not already there */
697 str = strstr( filename, ".gplot" );
698 if( (str == NULL) || (str[6] != '\0') )
699 Strlcat( filename, ".gplot", s );
700 Save_FreqPlots_Gnuplot_Data( filename );
701 }
702 else if( isFlagSet(STRCT_GNUPLOT_SAVE) )
703 {
704 /* cat a file extension if not already there */
705 str = strstr( filename, ".gplot" );
706 if( (str == NULL) || (str[6] != '\0') )
707 Strlcat( filename, ".gplot", s );
708 Save_Struct_Gnuplot_Data( filename );
709 }
710
711 gtk_widget_destroy( file_selection );
712 if( (kill_window == nec2_edit_window) &&
713 (kill_window != NULL) )
714 gtk_widget_destroy( nec2_edit_window );
715 } /* if( response_id == GTK_RESPONSE_OK ) */
716 }
717
718
719 gboolean
on_freqplots_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)720 on_freqplots_window_delete_event (GtkWidget *widget,
721 GdkEvent *event,
722 gpointer user_data)
723 {
724 kill_window = freqplots_window;
725 Delete_Event( _("Really close window?") );
726 return TRUE;
727 }
728
729
730 void
on_freqplots_window_destroy(GtkObject * object,gpointer user_data)731 on_freqplots_window_destroy (GtkObject *object,
732 gpointer user_data)
733 {
734 Plots_Window_Killed();
735 }
736
737
738 void
on_freqplots_save_activate(GtkMenuItem * menuitem,gpointer user_data)739 on_freqplots_save_activate (GtkMenuItem *menuitem,
740 gpointer user_data)
741 {
742 char saveas[96];
743 size_t s = sizeof( saveas );
744 static int cnt = 0;
745
746 if( (strlen(infile) == 0) || isFlagClear(PLOT_SELECT) )
747 return;
748
749 /* Make file name from input file name,
750 * to save frequency plots drawing */
751 snprintf( saveas, s, "%s-%s_%03d.%s", infile, "plots", ++cnt, "png" );
752 saveas_pixmap = freqplots_pixmap;
753 saveas_pixmap_width = freqplots_pixmap_width;
754 saveas_pixmap_height = freqplots_pixmap_height;
755 ClearFlag( ALL_SAVE_FLAGS );
756 SetFlag( IMAGE_SAVE );
757
758 /* Open file selector to specify file */
759 /* name for saving the structure image */
760 file_selection = create_fileselection();
761 gtk_file_selection_set_filename( GTK_FILE_SELECTION(file_selection), saveas );
762 gtk_widget_show( file_selection );
763 }
764
765
766 void
on_freqplots_save_as_activate(GtkMenuItem * menuitem,gpointer user_data)767 on_freqplots_save_as_activate (GtkMenuItem *menuitem,
768 gpointer user_data)
769 {
770 saveas_pixmap = freqplots_pixmap;
771 saveas_pixmap_width = freqplots_pixmap_width;
772 saveas_pixmap_height = freqplots_pixmap_height;
773 ClearFlag( ALL_SAVE_FLAGS );
774 SetFlag( IMAGE_SAVE );
775
776 /* Open file selector to specify a file
777 * name for saving the freq plots image */
778 file_selection = create_fileselection();
779 gtk_widget_show( file_selection );
780 }
781
782
783 void
on_freqplots_save_as_gnuplot_activate(GtkMenuItem * menuitem,gpointer user_data)784 on_freqplots_save_as_gnuplot_activate (GtkMenuItem *menuitem,
785 gpointer user_data)
786 {
787 /* Open file selector to specify a file
788 * name for saving the rad pattern image */
789 ClearFlag( ALL_SAVE_FLAGS );
790 SetFlag( PLOTS_GNUPLOT_SAVE );
791 file_selection = create_fileselection();
792 gtk_widget_show( file_selection );
793 }
794
795
796 void
on_freqplots_gmax_togglebutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)797 on_freqplots_gmax_togglebutton_toggled (GtkToggleButton *togglebutton,
798 gpointer user_data)
799 {
800 /* Enable or not max gain plotting */
801 Plot_Select( togglebutton, PLOT_GMAX );
802 }
803
804
805 void
on_freqplots_gdir_togglebutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)806 on_freqplots_gdir_togglebutton_toggled (GtkToggleButton *togglebutton,
807 gpointer user_data)
808 {
809 /* Enable or not gain direction plotting */
810 Plot_Select( togglebutton, PLOT_GAIN_DIR );
811 }
812
813
814 void
on_freqplots_gviewer_togglebutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)815 on_freqplots_gviewer_togglebutton_toggled(GtkToggleButton *togglebutton,
816 gpointer user_data)
817 {
818 /* Enable or not "gain toward user" plotting */
819 Plot_Select( togglebutton, PLOT_GVIEWER );
820 }
821
822
823 void
on_freqplots_vswr_togglebutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)824 on_freqplots_vswr_togglebutton_toggled (GtkToggleButton *togglebutton,
825 gpointer user_data)
826 {
827 /* Enable or not VSWR plotting */
828 Plot_Select( togglebutton, PLOT_VSWR );
829 }
830
831
832 void
on_freqplots_zo_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)833 on_freqplots_zo_spinbutton_value_changed( GtkSpinButton *spinbutton,
834 gpointer user_data)
835 {
836 /* Set the value of Z0 used for VSWR calculations */
837 calc_data.zo = gtk_spin_button_get_value(spinbutton);
838 if( isFlagSet(PLOT_ENABLED) )
839 Plot_Frequency_Data();
840 gtk_spin_button_update( spinbutton );
841 }
842
843
844 void
on_freqplots_zrlzim_togglebutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)845 on_freqplots_zrlzim_togglebutton_toggled( GtkToggleButton *togglebutton,
846 gpointer user_data)
847 {
848 /* Enable or not Z-real/Z-imag plotting */
849 Plot_Select( togglebutton, PLOT_ZREAL_ZIMAG );
850 }
851
852
853 void
on_freqplots_zmgzph_togglebutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)854 on_freqplots_zmgzph_togglebutton_toggled( GtkToggleButton *togglebutton,
855 gpointer user_data)
856 {
857 /* Enable or not Z-mag/Z-phase plotting */
858 Plot_Select( togglebutton, PLOT_ZMAG_ZPHASE );
859 }
860
861
862 gboolean
on_freqplots_drawingarea_expose_event(GtkWidget * widget,GdkEventExpose * event,gpointer user_data)863 on_freqplots_drawingarea_expose_event (GtkWidget *widget,
864 GdkEventExpose *event,
865 gpointer user_data)
866 {
867 /* No redraws if new input pending */
868 if( isFlagSet(INPUT_PENDING) )
869 return FALSE;
870
871 /* Enable drawing of freq line */
872 Plot_Frequency_Data();
873 return TRUE;
874 }
875
876
877 gboolean
on_freqplots_drawingarea_configure_event(GtkWidget * widget,GdkEventConfigure * event,gpointer user_data)878 on_freqplots_drawingarea_configure_event( GtkWidget *widget,
879 GdkEventConfigure *event,
880 gpointer user_data)
881 {
882 /* Create or resize pixmap for frequency plots */
883 Create_Pixmap(
884 &freqplots_pixmap,
885 &freqplots_pixmap_width,
886 &freqplots_pixmap_height,
887 widget, event, NULL );
888 return TRUE;
889 }
890
891
892 gboolean
on_freqplots_drawingarea_button_press_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)893 on_freqplots_drawingarea_button_press_event(GtkWidget *widget,
894 GdkEventButton *event,
895 gpointer user_data)
896 {
897 /* No redraws if new input pending */
898 if( isFlagSet(INPUT_PENDING) )
899 return FALSE;
900
901 Set_Frequency_On_Click( event );
902 return TRUE;
903 }
904
905
906 void
on_rdpattern_window_destroy(GtkObject * object,gpointer user_data)907 on_rdpattern_window_destroy (GtkObject *object,
908 gpointer user_data)
909 {
910 Rdpattern_Window_Killed();
911 }
912
913
914 gboolean
on_rdpattern_window_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)915 on_rdpattern_window_delete_event (GtkWidget *widget,
916 GdkEvent *event,
917 gpointer user_data)
918 {
919 kill_window = rdpattern_window;
920 Delete_Event( _("Really close window?") );
921 return TRUE;
922 }
923
924
925 void
on_rdpattern_save_activate(GtkMenuItem * menuitem,gpointer user_data)926 on_rdpattern_save_activate (GtkMenuItem *menuitem,
927 gpointer user_data)
928 {
929 char saveas[96];
930 size_t s = sizeof( saveas );
931 static int cgn = 0, ceh = 0;;
932
933 if( strlen(infile) == 0 )
934 return;
935
936 /* Make the rad pattern save
937 * file name from input name */
938 if( isFlagSet(DRAW_GAIN) )
939 snprintf( saveas, s, "%s-%s_%03d.%s", infile, "gain", ++cgn, "png" );
940 else if( isFlagSet(DRAW_EHFIELD) )
941 snprintf( saveas, s, "%s-%s_%03d.%s", infile, "fields", ++ceh, "png" );
942 else return;
943
944 saveas_pixmap = rdpattern_pixmap;
945 saveas_pixmap_width = rdpattern_pixmap_width;
946 saveas_pixmap_height = rdpattern_pixmap_height;
947 ClearFlag( ALL_SAVE_FLAGS );
948 SetFlag( IMAGE_SAVE );
949
950 /* Open file selector to specify file */
951 /* name for saving the pattern image */
952 file_selection = create_fileselection();
953 gtk_file_selection_set_filename( GTK_FILE_SELECTION(file_selection), saveas );
954 gtk_widget_show( file_selection );
955 }
956
957
958 void
on_rdpattern_save_as_activate(GtkMenuItem * menuitem,gpointer user_data)959 on_rdpattern_save_as_activate (GtkMenuItem *menuitem,
960 gpointer user_data)
961 {
962 saveas_pixmap = rdpattern_pixmap;
963 saveas_pixmap_width = rdpattern_pixmap_width;
964 saveas_pixmap_height = rdpattern_pixmap_height;
965 ClearFlag( ALL_SAVE_FLAGS );
966 SetFlag( IMAGE_SAVE );
967
968 /* Open file selector to specify a file
969 * name for saving the rad pattern image */
970 file_selection = create_fileselection();
971 gtk_widget_show( file_selection );
972 }
973
974
975 void
on_rdpattern_save_as_gnuplot_activate(GtkMenuItem * menuitem,gpointer user_data)976 on_rdpattern_save_as_gnuplot_activate (GtkMenuItem *menuitem,
977 gpointer user_data)
978 {
979 /* Open file selector to specify a file
980 * name for saving the rad pattern image */
981 ClearFlag( ALL_SAVE_FLAGS );
982 SetFlag( RDPAT_GNUPLOT_SAVE );
983 file_selection = create_fileselection();
984 gtk_widget_show( file_selection );
985 }
986
987
988 void
on_rdpattern_linear_power_activate(GtkMenuItem * menuitem,gpointer user_data)989 on_rdpattern_linear_power_activate (GtkMenuItem *menuitem,
990 gpointer user_data)
991 {
992 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
993 Set_Gain_Style( GS_LINP );
994 }
995
996
997 void
on_rdpattern_linear_voltage_activate(GtkMenuItem * menuitem,gpointer user_data)998 on_rdpattern_linear_voltage_activate (GtkMenuItem *menuitem,
999 gpointer user_data)
1000 {
1001 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
1002 Set_Gain_Style( GS_LINV );
1003 }
1004
1005
1006 void
on_rdpattern_arrl_style_activate(GtkMenuItem * menuitem,gpointer user_data)1007 on_rdpattern_arrl_style_activate (GtkMenuItem *menuitem,
1008 gpointer user_data)
1009 {
1010 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
1011 Set_Gain_Style( GS_ARRL );
1012 }
1013
1014
1015 void
on_rdpattern_logarithmic_activate(GtkMenuItem * menuitem,gpointer user_data)1016 on_rdpattern_logarithmic_activate (GtkMenuItem *menuitem,
1017 gpointer user_data)
1018 {
1019 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
1020 Set_Gain_Style( GS_LOG );
1021 }
1022
1023
1024 void
on_rdpattern_e_field_activate(GtkMenuItem * menuitem,gpointer user_data)1025 on_rdpattern_e_field_activate (GtkMenuItem *menuitem,
1026 gpointer user_data)
1027 {
1028 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
1029 SetFlag( DRAW_EFIELD );
1030 else
1031 ClearFlag( DRAW_EFIELD );
1032 Set_Window_Labels();
1033 if( isFlagSet(DRAW_EHFIELD) )
1034 Draw_Radiation( rdpattern_drawingarea );
1035 }
1036
1037
1038 void
on_rdpattern_h_field_activate(GtkMenuItem * menuitem,gpointer user_data)1039 on_rdpattern_h_field_activate (GtkMenuItem *menuitem,
1040 gpointer user_data)
1041 {
1042 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
1043 SetFlag( DRAW_HFIELD );
1044 else
1045 ClearFlag( DRAW_HFIELD );
1046 Set_Window_Labels();
1047 if( isFlagSet(DRAW_EHFIELD) )
1048 Draw_Radiation( rdpattern_drawingarea );
1049 }
1050
1051
1052 void
on_rdpattern_poynting_vector_activate(GtkMenuItem * menuitem,gpointer user_data)1053 on_rdpattern_poynting_vector_activate (GtkMenuItem *menuitem,
1054 gpointer user_data)
1055 {
1056 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
1057 SetFlag( DRAW_POYNTING );
1058 else
1059 ClearFlag( DRAW_POYNTING );
1060 Set_Window_Labels();
1061 if( isFlagSet(DRAW_EHFIELD) )
1062 Draw_Radiation( rdpattern_drawingarea );
1063 }
1064
1065
1066 void
on_rdpattern_overlay_structure_activate(GtkMenuItem * menuitem,gpointer user_data)1067 on_rdpattern_overlay_structure_activate (GtkMenuItem *menuitem,
1068 gpointer user_data)
1069 {
1070 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
1071 SetFlag( OVERLAY_STRUCT );
1072 else
1073 ClearFlag( OVERLAY_STRUCT );
1074 Draw_Radiation( rdpattern_drawingarea );
1075 }
1076
1077
1078 void
on_rdpattern_x_axis_clicked(GtkButton * button,gpointer user_data)1079 on_rdpattern_x_axis_clicked (GtkButton *button,
1080 gpointer user_data)
1081 {
1082 /* Recalculate projection paramenters */
1083 New_Viewer_Angle( 0.0, 0.0, rotate_rdpattern,
1084 incline_rdpattern, &rdpattern_proj_params );
1085 if( isFlagSet(COMMON_PROJECTION) )
1086 New_Viewer_Angle( 0.0, 0.0, rotate_structure,
1087 incline_structure, &structure_proj_params );
1088 }
1089
1090
1091 void
on_rdpattern_y_axis_clicked(GtkButton * button,gpointer user_data)1092 on_rdpattern_y_axis_clicked (GtkButton *button,
1093 gpointer user_data)
1094 {
1095 /* Recalculate projection paramenters */
1096 New_Viewer_Angle( 90.0, 0.0, rotate_rdpattern,
1097 incline_rdpattern, &rdpattern_proj_params );
1098 if( isFlagSet(COMMON_PROJECTION) )
1099 New_Viewer_Angle( 90.0, 0.0, rotate_structure,
1100 incline_structure, &structure_proj_params );
1101 }
1102
1103
1104 void
on_rdpattern_z_axis_clicked(GtkButton * button,gpointer user_data)1105 on_rdpattern_z_axis_clicked (GtkButton *button,
1106 gpointer user_data)
1107 {
1108 /* Recalculate projection paramenters */
1109 New_Viewer_Angle( 0.0, 90.0, rotate_rdpattern,
1110 incline_rdpattern, &rdpattern_proj_params );
1111 if( isFlagSet(COMMON_PROJECTION) )
1112 New_Viewer_Angle( 0.0, 90.0, rotate_structure,
1113 incline_structure, &structure_proj_params );
1114 }
1115
1116
1117 void
on_rdpattern_default_view_clicked(GtkButton * button,gpointer user_data)1118 on_rdpattern_default_view_clicked
1119 (GtkButton *button,
1120 gpointer user_data)
1121 {
1122 /* Projection at 45 deg rotation and inclination */
1123 New_Viewer_Angle( 45.0, 45.0, rotate_rdpattern,
1124 incline_rdpattern, &rdpattern_proj_params );
1125 if( isFlagSet(COMMON_PROJECTION) )
1126 New_Viewer_Angle( 45.0, 45.0, rotate_structure,
1127 incline_structure, &structure_proj_params );
1128 }
1129
1130
1131 void
on_rdpattern_rotate_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)1132 on_rdpattern_rotate_spinbutton_value_changed(
1133 GtkSpinButton *spinbutton,
1134 gpointer user_data)
1135 {
1136 /* No redraws if new input pending */
1137 if( isFlagSet(INPUT_PENDING) )
1138 return;
1139
1140 /* Get new value of "rotate pattern" angle from spinbutton */
1141 rdpattern_proj_params.Wr = gtk_spin_button_get_value(spinbutton);
1142
1143 /* Sync main window rotate spinbutton */
1144 if( isFlagSet(COMMON_PROJECTION) )
1145 gtk_spin_button_set_value(
1146 rotate_structure, (gdouble)rdpattern_proj_params.Wr );
1147
1148 New_Radiation_Projection_Angle();
1149 gtk_spin_button_update( spinbutton );
1150 }
1151
1152
1153 void
on_rdpattern_incline_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)1154 on_rdpattern_incline_spinbutton_value_changed(
1155 GtkSpinButton *spinbutton,
1156 gpointer user_data)
1157 {
1158 /* No redraws if new input pending */
1159 if( isFlagSet(INPUT_PENDING) )
1160 return;
1161
1162 /* Get new value of "incline pattern" angle from spinbutton */
1163 rdpattern_proj_params.Wi = gtk_spin_button_get_value(spinbutton);
1164
1165 /* Sync main window incline spinbutton */
1166 if( isFlagSet(COMMON_PROJECTION) )
1167 gtk_spin_button_set_value(
1168 incline_structure, (gdouble)rdpattern_proj_params.Wi );
1169
1170 New_Radiation_Projection_Angle();
1171 gtk_spin_button_update( spinbutton );
1172 }
1173
1174
1175 void
on_rdpattern_gain_togglebutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)1176 on_rdpattern_gain_togglebutton_toggled (GtkToggleButton *togglebutton,
1177 gpointer user_data)
1178 {
1179 Rdpattern_Gain_Togglebutton_Toggled(
1180 gtk_toggle_button_get_active(togglebutton) );
1181 }
1182
1183
1184 void
on_rdpattern_eh_togglebutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)1185 on_rdpattern_eh_togglebutton_toggled (GtkToggleButton *togglebutton,
1186 gpointer user_data)
1187 {
1188 Rdpattern_EH_Togglebutton_Toggled(
1189 gtk_toggle_button_get_active(togglebutton) );
1190 }
1191
1192
1193 gboolean
on_rdpattern_colorcode_drawingarea_expose_event(GtkWidget * widget,GdkEventExpose * event,gpointer user_data)1194 on_rdpattern_colorcode_drawingarea_expose_event(GtkWidget *widget,
1195 GdkEventExpose *event,
1196 gpointer user_data)
1197 {
1198 double red = 0.0, grn = 0.0, blu = 0.0;
1199 int idx;
1200
1201 /* No redraws if new input pending */
1202 if( isFlagSet(INPUT_PENDING) )
1203 return FALSE;
1204
1205 cairo_t *cr = gdk_cairo_create( widget-> window );
1206
1207 /* Draw color code bar in rad pattern window */
1208 for( idx = 0; idx < 160; idx++ )
1209 {
1210 Value_to_Color( &red, &grn, &blu, (double) (8*idx), 1280.0 );
1211 cairo_set_source_rgb( cr, red, grn, blu );
1212 Cairo_Draw_Line( cr, idx, 0, idx, 28 );
1213 }
1214
1215 cairo_destroy( cr );
1216 return TRUE;
1217 }
1218
1219
1220 void
on_rdpattern_freq_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)1221 on_rdpattern_freq_spinbutton_value_changed( GtkSpinButton *spinbutton,
1222 gpointer user_data)
1223 {
1224 static gdouble fmhz_save = 0.0;
1225
1226 /* No redraws if new input pending */
1227 if( isFlagSet(INPUT_PENDING) )
1228 return;
1229
1230 /* Frequency spinbutton value changed by frequency loop */
1231 if( isFlagSet(FREQ_LOOP_RUNNING) && isFlagSet(DRAW_ENABLED) )
1232 Draw_Radiation( rdpattern_drawingarea );
1233 else
1234 {
1235 /* Get freq from spin button, avoid double signal by GTK */
1236 gdouble fmhz = (gdouble)gtk_spin_button_get_value(spinbutton);
1237 if( fmhz == fmhz_save ) return; /* to avoid double signal by GTK */
1238 fmhz_save = fmhz;
1239
1240 /* If new freq calculations are enabled
1241 * by checkbutton next to freq spinbutton */
1242 if( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
1243 lookup_widget(rdpattern_window,
1244 "rdpattern_freq_checkbutton"))) &&
1245 (isFlagSet(DRAW_GAIN) || isFlagSet(DRAW_EHFIELD)) )
1246 {
1247 /* Recalc currents in structure and rad pattern */
1248 calc_data.fmhz = (double)fmhz;
1249 g_idle_add( Redo_Radiation_Pattern, NULL );
1250 }
1251
1252 /* Sync main window frequency spinbutton */
1253 if( isFlagSet(COMMON_FREQUENCY) )
1254 gtk_spin_button_set_value( mainwin_frequency, fmhz );
1255 } /* else */
1256 gtk_spin_button_update( spinbutton );
1257 }
1258
1259
1260 void
on_rdpattern_new_freq_clicked(GtkButton * button,gpointer user_data)1261 on_rdpattern_new_freq_clicked (GtkButton *button,
1262 gpointer user_data)
1263 {
1264 /* Recalculate and draw rad pattern after user command */
1265 if( isFlagClear(FREQ_LOOP_RUNNING) )
1266 {
1267 calc_data.fmhz =
1268 (double)gtk_spin_button_get_value( rdpattern_frequency );
1269 Redo_Radiation_Pattern( NULL );
1270 }
1271 }
1272
1273
1274 gboolean
on_rdpattern_drawingarea_configure_event(GtkWidget * widget,GdkEventConfigure * event,gpointer user_data)1275 on_rdpattern_drawingarea_configure_event( GtkWidget *widget,
1276 GdkEventConfigure *event,
1277 gpointer user_data)
1278 {
1279 /* Create or resize rad pattern pixmap */
1280 Create_Pixmap(
1281 &rdpattern_pixmap,
1282 &rdpattern_pixmap_width,
1283 &rdpattern_pixmap_height,
1284 widget, event,
1285 &rdpattern_proj_params );
1286 return TRUE;
1287 }
1288
1289
1290 gboolean
on_rdpattern_drawingarea_expose_event(GtkWidget * widget,GdkEventExpose * event,gpointer user_data)1291 on_rdpattern_drawingarea_expose_event (GtkWidget *widget,
1292 GdkEventExpose *event,
1293 gpointer user_data)
1294 {
1295 /* No redraws if new input pending */
1296 if( isFlagSet(INPUT_PENDING) )
1297 return FALSE;
1298
1299 Draw_Radiation( widget );
1300 return TRUE;
1301 }
1302
1303
1304 gboolean
on_rdpattern_drawingarea_motion_notify_event(GtkWidget * widget,GdkEventMotion * event,gpointer user_data)1305 on_rdpattern_drawingarea_motion_notify_event( GtkWidget *widget,
1306 GdkEventMotion *event,
1307 gpointer user_data)
1308 {
1309 /* Use only 1 in MOTION_EVENTS_COUNT event */
1310 static int cnt = 0;
1311 if( cnt++ < MOTION_EVENTS_COUNT )
1312 return FALSE;
1313 cnt = 0;
1314
1315 /* Block motion events */
1316 g_signal_handler_block(
1317 (gpointer)rdpattern_drawingarea, rdpattern_motion_handler );
1318
1319 /* No redraws if new input pending */
1320 if( isFlagSet(INPUT_PENDING) )
1321 return FALSE;
1322
1323 /* Handle motion events */
1324 Motion_Event( event, &rdpattern_proj_params );
1325
1326 /* Unblock motion events */
1327 g_signal_handler_unblock(
1328 (gpointer)rdpattern_drawingarea, rdpattern_motion_handler );
1329
1330 return TRUE;
1331 }
1332
1333
1334 void
on_quit_cancelbutton_clicked(GtkButton * button,gpointer user_data)1335 on_quit_cancelbutton_clicked (GtkButton *button,
1336 gpointer user_data)
1337 {
1338 gtk_widget_destroy( quit_dialog );
1339 ClearFlag( MAIN_QUIT );
1340 }
1341
1342
1343 void
on_quit_okbutton_clicked(GtkButton * button,gpointer user_data)1344 on_quit_okbutton_clicked (GtkButton *button,
1345 gpointer user_data)
1346 {
1347 if( isFlagSet(FREQ_LOOP_RUNNING) )
1348 {
1349 if( isFlagSet(MAIN_QUIT) )
1350 {
1351 Stop_Frequency_Loop();
1352 gtk_label_set_text( GTK_LABEL(
1353 lookup_widget( quit_dialog, "quit_label")),
1354 _("Really quit Xnec2c?") );
1355 ClearFlag( MAIN_QUIT );
1356 return;
1357 }
1358
1359 /* Stop freq loop if only one of plots
1360 * or radiation pattern windows is open */
1361 if( (isFlagSet(DRAW_ENABLED) && isFlagClear(PLOT_ENABLED)) ||
1362 (isFlagClear(DRAW_ENABLED) && isFlagSet(PLOT_ENABLED)) )
1363 Stop_Frequency_Loop();
1364
1365 } /* if( isFlagSet(FREQ_LOOP_RUNNING) ) */
1366
1367 gtk_widget_destroy( quit_dialog );
1368 gtk_widget_destroy( kill_window );
1369 }
1370
1371
1372 void
main_view_menuitem_activate(GtkMenuItem * menuitem,gpointer user_data)1373 main_view_menuitem_activate (GtkMenuItem *menuitem,
1374 gpointer user_data)
1375 {
1376 /* Sync common projection checkbuttons */
1377 if( isFlagSet(COMMON_PROJECTION) )
1378 gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(
1379 lookup_widget(main_window,
1380 "common_projection")), TRUE );
1381 else
1382 gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(
1383 lookup_widget(main_window,
1384 "common_projection")), FALSE );
1385
1386 /* Sync common frequency checkbuttons */
1387 if( isFlagSet(COMMON_FREQUENCY) )
1388 gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(
1389 lookup_widget(main_window,
1390 "common_freq")), TRUE );
1391 else
1392 gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(
1393 lookup_widget(main_window,
1394 "common_freq")), FALSE );
1395
1396 }
1397
1398
1399 void
main_pol_menu_activate(GtkMenuItem * menuitem,gpointer user_data)1400 main_pol_menu_activate (GtkMenuItem *menuitem,
1401 gpointer user_data)
1402 {
1403 Set_Pol_Menuitem( menuitem );
1404 }
1405
1406
1407 void
freqplots_pol_menu_activate(GtkMenuItem * menuitem,gpointer user_data)1408 freqplots_pol_menu_activate (GtkMenuItem *menuitem,
1409 gpointer user_data)
1410 {
1411 Set_Pol_Menuitem( menuitem );
1412 }
1413
1414
1415 void
rdpattern_view_menuitem_activate(GtkMenuItem * menuitem,gpointer user_data)1416 rdpattern_view_menuitem_activate (GtkMenuItem *menuitem,
1417 gpointer user_data)
1418 {
1419 /* Sync common projection checkbuttons */
1420 if( isFlagSet(COMMON_PROJECTION) )
1421 gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(
1422 lookup_widget(rdpattern_window,
1423 "common_projection")), TRUE );
1424 else
1425 gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(
1426 lookup_widget(rdpattern_window,
1427 "common_projection")), FALSE );
1428
1429 /* Sync common frequency checkbuttons */
1430 if( isFlagSet(COMMON_FREQUENCY) )
1431 gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(
1432 lookup_widget(rdpattern_window,
1433 "common_freq")), TRUE );
1434 else
1435 gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(
1436 lookup_widget(rdpattern_window,
1437 "common_freq")), FALSE );
1438 }
1439
1440
1441 void
rdpattern_pol_menu_activate(GtkMenuItem * menuitem,gpointer user_data)1442 rdpattern_pol_menu_activate (GtkMenuItem *menuitem,
1443 gpointer user_data)
1444 {
1445 Set_Pol_Menuitem( menuitem );
1446 }
1447
1448
1449 void
on_filechoser_cancel_clicked(GtkButton * button,gpointer user_data)1450 on_filechoser_cancel_clicked (GtkButton *button,
1451 gpointer user_data)
1452 {
1453 gtk_widget_destroy( file_chooser );
1454 }
1455
1456
1457 void
on_fileselection_cancel_clicked(GtkButton * button,gpointer user_data)1458 on_fileselection_cancel_clicked (GtkButton *button,
1459 gpointer user_data)
1460 {
1461 gtk_widget_destroy( file_selection );
1462 }
1463
1464
1465 void
on_near_peak_value_activate(GtkMenuItem * menuitem,gpointer user_data)1466 on_near_peak_value_activate (GtkMenuItem *menuitem,
1467 gpointer user_data)
1468 {
1469 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
1470 {
1471 ClearFlag( NEAREH_SNAPSHOT );
1472 /* Redraw radiation pattern drawingarea */
1473 if( isFlagSet(DRAW_EHFIELD) )
1474 {
1475 near_field.valid = 0;
1476 Near_Field_Pattern();
1477 Draw_Radiation( rdpattern_drawingarea );
1478 }
1479 }
1480 else SetFlag( NEAREH_SNAPSHOT );
1481
1482 /* Reset child near field flags */
1483 Pass_EH_Flags();
1484 }
1485
1486
1487 void
on_near_snapshot_activate(GtkMenuItem * menuitem,gpointer user_data)1488 on_near_snapshot_activate (GtkMenuItem *menuitem,
1489 gpointer user_data)
1490 {
1491 if( gtk_check_menu_item_get_active(
1492 GTK_CHECK_MENU_ITEM(menuitem)) )
1493 {
1494 SetFlag( NEAREH_SNAPSHOT );
1495 /* Redraw radiation pattern drawingarea */
1496 if( isFlagSet(DRAW_EHFIELD) )
1497 {
1498 near_field.valid = 0;
1499 Near_Field_Pattern();
1500 Draw_Radiation( rdpattern_drawingarea );
1501 }
1502 }
1503 else ClearFlag( NEAREH_SNAPSHOT );
1504
1505 /* Reset child near field flags */
1506 Pass_EH_Flags();
1507 }
1508
1509
1510 void
on_rdpattern_animate_activate(GtkMenuItem * menuitem,gpointer user_data)1511 on_rdpattern_animate_activate (GtkMenuItem *menuitem,
1512 gpointer user_data)
1513 {
1514 if( isFlagClear(DRAW_EHFIELD) )
1515 return;
1516
1517 if( animate_dialog == NULL )
1518 animate_dialog = create_animate_dialog();
1519 gtk_widget_show( animate_dialog );
1520 }
1521
1522
1523 void
on_animation_applybutton_clicked(GtkButton * button,gpointer user_data)1524 on_animation_applybutton_clicked (GtkButton *button,
1525 gpointer user_data)
1526 {
1527 GtkSpinButton *spinbutton;
1528 guint intval;
1529 gdouble freq, steps;
1530
1531 spinbutton = GTK_SPIN_BUTTON( lookup_widget(animate_dialog,
1532 "animate_freq_spinbutton") );
1533 freq = gtk_spin_button_get_value( spinbutton );
1534 spinbutton = GTK_SPIN_BUTTON( lookup_widget(animate_dialog,
1535 "animate_steps_spinbutton") );
1536 steps = gtk_spin_button_get_value( spinbutton );
1537 intval = (guint)(1000.0 / steps / freq);
1538 near_field.anim_step = (double)TP / steps;
1539
1540 SetFlag( NEAREH_ANIMATE );
1541 if( anim_tag > 0 )
1542 g_source_remove( anim_tag );
1543 anim_tag = g_timeout_add( intval, Animate_Near_Field, NULL );
1544 }
1545
1546
1547 void
on_animation_cancelbutton_clicked(GtkButton * button,gpointer user_data)1548 on_animation_cancelbutton_clicked (GtkButton *button,
1549 gpointer user_data)
1550 {
1551 ClearFlag( NEAREH_ANIMATE );
1552 g_source_remove( anim_tag );
1553 anim_tag = 0;
1554 }
1555
1556
1557 void
on_animation_okbutton_clicked(GtkButton * button,gpointer user_data)1558 on_animation_okbutton_clicked (GtkButton *button,
1559 gpointer user_data)
1560 {
1561 GtkSpinButton *spinbutton;
1562 guint intval;
1563 gdouble freq, steps;
1564
1565 spinbutton = GTK_SPIN_BUTTON( lookup_widget(animate_dialog,
1566 "animate_freq_spinbutton") );
1567 freq = gtk_spin_button_get_value( spinbutton );
1568 spinbutton = GTK_SPIN_BUTTON( lookup_widget(animate_dialog,
1569 "animate_steps_spinbutton") );
1570 steps = gtk_spin_button_get_value( spinbutton );
1571 intval = (guint)(1000.0 / steps / freq);
1572 near_field.anim_step = (double)TP / steps;
1573
1574 SetFlag( NEAREH_ANIMATE );
1575 if( anim_tag > 0 )
1576 g_source_remove( anim_tag );
1577 anim_tag = g_timeout_add( intval, Animate_Near_Field, NULL );
1578
1579 gtk_widget_hide( animate_dialog );
1580 }
1581
1582
1583 void
on_animate_dialog_destroy(GtkObject * object,gpointer user_data)1584 on_animate_dialog_destroy (GtkObject *object,
1585 gpointer user_data)
1586 {
1587 animate_dialog = NULL;
1588 }
1589
1590
1591 void
on_quit_dialog_destroy(GtkObject * object,gpointer user_data)1592 on_quit_dialog_destroy (GtkObject *object,
1593 gpointer user_data)
1594 {
1595 quit_dialog = NULL;
1596 }
1597
1598
1599 gboolean
on_error_dialog_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)1600 on_error_dialog_delete_event (GtkWidget *widget,
1601 GdkEvent *event,
1602 gpointer user_data)
1603 {
1604 return TRUE;
1605 }
1606
1607
1608 void
on_nec2_edit_activate(GtkMenuItem * menuitem,gpointer user_data)1609 on_nec2_edit_activate (GtkMenuItem *menuitem,
1610 gpointer user_data)
1611 {
1612 /* Abort if no open input file */
1613 if( input_fp == NULL )
1614 {
1615 stop( _("No open NEC2 input file"), ERR_OK );
1616 return;
1617 }
1618
1619 if( nec2_edit_window == NULL )
1620 Open_Nec2_Editor( NEC2_EDITOR_RELOAD );
1621 }
1622
1623
1624 gboolean
on_nec2_editor_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)1625 on_nec2_editor_delete_event (GtkWidget *widget,
1626 GdkEvent *event,
1627 gpointer user_data)
1628 {
1629 if( isFlagSet(NEC2_EDIT_SAVE) )
1630 {
1631 /* Open file selector to specify file */
1632 /* name for saving a new NEC2 input file */
1633 if( strlen(infile) == 0 )
1634 {
1635 file_selection = create_fileselection();
1636 gtk_file_selection_set_filename(
1637 GTK_FILE_SELECTION(file_selection), _("untitled") );
1638 gtk_widget_show( file_selection );
1639 ClearFlag( ALL_SAVE_FLAGS );
1640 ClearFlag( NEC2_EDIT_SAVE );
1641 SetFlag( NEC2_SAVE );
1642 kill_window = nec2_edit_window;
1643 return TRUE;
1644 }
1645
1646 Save_Nec2_Input_File( nec2_edit_window, infile );
1647 }
1648
1649 kill_window = nec2_edit_window;
1650 Delete_Event( _("Really close NEC2 Editor?") );
1651 return TRUE;
1652 }
1653
1654
1655 void
on_nec2_editor_destroy(GtkObject * object,gpointer user_data)1656 on_nec2_editor_destroy (GtkObject *object,
1657 gpointer user_data)
1658 {
1659 cmnt_store = NULL,
1660 geom_store = NULL,
1661 cmnd_store = NULL;
1662 nec2_edit_window = NULL;
1663 kill_window = NULL;
1664 }
1665
1666
1667 void
on_nec2_save_clicked(GtkButton * button,gpointer user_data)1668 on_nec2_save_clicked( GtkButton *button,
1669 gpointer user_data)
1670 {
1671 gboolean new = FALSE;
1672
1673 /* No save/open file while freq loop is running */
1674 if( !Nec2_Save_Warn(
1675 _("NEC2 Editor's data may not be saved\n"\
1676 "while the Frequency Loop is running")) )
1677 return;
1678
1679 /* Open file selector to specify file */
1680 /* name for saving a new NEC2 input file */
1681 if( strlen(infile) == 0 )
1682 {
1683 file_selection = create_fileselection();
1684 gtk_file_selection_set_filename(
1685 GTK_FILE_SELECTION(file_selection), _("untitled") );
1686 gtk_widget_show( file_selection );
1687 ClearFlag( ALL_SAVE_FLAGS );
1688 SetFlag( NEC2_SAVE );
1689 return;
1690 }
1691
1692 /* Save NEC2 editor data */
1693 Save_Nec2_Input_File( nec2_edit_window, infile );
1694 if( Nec2_Apply_Checkbutton() )
1695 Open_Input_File( (gpointer)&new );
1696 }
1697
1698
1699 void
on_nec2_save_as_clicked(GtkButton * button,gpointer user_data)1700 on_nec2_save_as_clicked (GtkButton *button,
1701 gpointer user_data)
1702 {
1703 /* No save/open file while freq loop is running */
1704 if( !Nec2_Save_Warn(
1705 _("NEC2 Editor's data may not be saved\n"\
1706 "while the Frequency Loop is running")) )
1707 return;
1708
1709 /* Open file selector to specify file */
1710 /* name for saving the edited NEC2 file */
1711 file_selection = create_fileselection();
1712 gtk_file_selection_set_filename(
1713 GTK_FILE_SELECTION(file_selection), _("untitled") );
1714 gtk_widget_show( file_selection );
1715 ClearFlag( ALL_SAVE_FLAGS );
1716 SetFlag( NEC2_SAVE );
1717 }
1718
1719
1720 void
on_nec2_row_add_clicked(GtkButton * button,gpointer user_data)1721 on_nec2_row_add_clicked (GtkButton *button,
1722 gpointer user_data)
1723 {
1724 GtkTreeModel *model;
1725 GtkTreeSelection *selection;
1726 GtkTreeIter iter, sibling;
1727 int ncols;
1728
1729 if( selected_treeview == NULL )
1730 return;
1731
1732 /* Find selected row and add new after */
1733 selection = gtk_tree_view_get_selection( selected_treeview );
1734 if( ! gtk_tree_selection_get_selected(selection, &model, &sibling) )
1735 {
1736 /* Empty tree view case */
1737 model = gtk_tree_view_get_model( selected_treeview );
1738 gtk_list_store_insert( GTK_LIST_STORE(model), &iter, 0 );
1739 }
1740 else gtk_list_store_insert_after(
1741 GTK_LIST_STORE(model), &iter, &sibling);
1742
1743 /* Prime columns of new row */
1744 ncols = gtk_tree_model_get_n_columns( model );
1745 if( ncols == 2 ) /* Comments treeview */
1746 gtk_list_store_set(
1747 GTK_LIST_STORE(model), &iter, 0, "CM", -1 );
1748 else
1749 {
1750 int idx;
1751 for( idx = 0; idx < ncols; idx++ )
1752 gtk_list_store_set(
1753 GTK_LIST_STORE(model), &iter, idx, "--", -1 );
1754 }
1755 }
1756
1757
1758 void
on_nec2_row_remv_clicked(GtkButton * button,gpointer user_data)1759 on_nec2_row_remv_clicked (GtkButton *button,
1760 gpointer user_data)
1761 {
1762 GtkTreeModel *model;
1763 GtkTreeIter iter;
1764 GtkTreeSelection *selection;
1765
1766 if( selected_treeview == NULL )
1767 return;
1768
1769 selection = gtk_tree_view_get_selection( selected_treeview );
1770 gtk_tree_selection_get_selected( selection, &model, &iter);
1771 gtk_list_store_remove( GTK_LIST_STORE(model), &iter );
1772 selected_treeview = NULL;
1773 }
1774
1775
1776 void
on_nec2_treeview_clear_clicked(GtkButton * button,gpointer user_data)1777 on_nec2_treeview_clear_clicked (GtkButton *button,
1778 gpointer user_data)
1779 {
1780 if( selected_treeview != NULL )
1781 gtk_list_store_clear( GTK_LIST_STORE(
1782 gtk_tree_view_get_model(selected_treeview)) );
1783 }
1784
1785
1786 gboolean
on_nec2_cmnt_treeview_button_press_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)1787 on_nec2_cmnt_treeview_button_press_event
1788 (GtkWidget *widget,
1789 GdkEventButton *event,
1790 gpointer user_data)
1791 {
1792 selected_treeview = GTK_TREE_VIEW(widget);
1793 if( event->button == 3 )
1794 Open_Editor(selected_treeview);
1795 return FALSE;
1796 }
1797
1798
1799 gboolean
on_nec2_geom_treeview_button_press_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)1800 on_nec2_geom_treeview_button_press_event
1801 (GtkWidget *widget,
1802 GdkEventButton *event,
1803 gpointer user_data)
1804 {
1805 selected_treeview = GTK_TREE_VIEW(widget);
1806 if( event->button == 3 )
1807 {
1808 action = EDITOR_EDIT;
1809 Open_Editor(selected_treeview);
1810 action = EDITOR_NEW;
1811 }
1812 return FALSE;
1813 }
1814
1815
1816 gboolean
on_nec2_cmnd_treeview_button_press_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)1817 on_nec2_cmnd_treeview_button_press_event
1818 (GtkWidget *widget,
1819 GdkEventButton *event,
1820 gpointer user_data)
1821 {
1822 selected_treeview = GTK_TREE_VIEW(widget);
1823 if( event->button == 3 )
1824 {
1825 action = EDITOR_EDIT;
1826 Open_Editor( selected_treeview );
1827 action = EDITOR_NEW;
1828 }
1829 return FALSE;
1830 }
1831
1832
1833 void
on_nec2_revert_clicked(GtkButton * button,gpointer user_data)1834 on_nec2_revert_clicked (GtkButton *button,
1835 gpointer user_data)
1836 {
1837 /* Open NEC2 input file */
1838 Open_File( &input_fp, infile, "r" );
1839 Nec2_Input_File_Treeview( NEC2_EDITOR_REVERT );
1840 }
1841
1842 void on_error_stopbutton_clicked(
1843 GtkButton *button, gpointer user_data) __attribute__ ((noreturn));
1844 void
on_error_stopbutton_clicked(GtkButton * button,gpointer user_data)1845 on_error_stopbutton_clicked (GtkButton *button,
1846 gpointer user_data)
1847 {
1848 ClearFlag( ERROR_CONDX );
1849 gtk_widget_destroy( error_dialog );
1850 gtk_main();
1851 exit(0);
1852 }
1853
1854
1855 void
on_error_okbutton_clicked(GtkButton * button,gpointer user_data)1856 on_error_okbutton_clicked (GtkButton *button,
1857 gpointer user_data)
1858 {
1859 ClearFlag( ERROR_CONDX );
1860 gtk_widget_destroy( error_dialog );
1861 }
1862
1863
1864 void
on_error_quitbutton_clicked(GtkButton * button,gpointer user_data)1865 on_error_quitbutton_clicked (GtkButton *button,
1866 gpointer user_data)
1867 {
1868 gtk_widget_destroy( error_dialog );
1869 gtk_widget_destroy( main_window );
1870 }
1871
1872
1873 void
on_wire_editor_destroy(GtkObject * object,gpointer user_data)1874 on_wire_editor_destroy (GtkObject *object,
1875 gpointer user_data)
1876 {
1877 wire_editor = NULL;
1878 }
1879
1880
1881 void
on_wire_pcl_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)1882 on_wire_pcl_spinbutton_value_changed (GtkSpinButton *spinbutton,
1883 gpointer user_data)
1884 {
1885 gtk_spin_button_update( spinbutton );
1886 Wire_Editor( EDITOR_SEGPC );
1887 }
1888
1889
1890 void
on_wire_data_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)1891 on_wire_data_spinbutton_value_changed (GtkSpinButton *spinbutton,
1892 gpointer user_data)
1893 {
1894 gtk_spin_button_update( spinbutton );
1895 Wire_Editor( EDITOR_DATA );
1896 }
1897
1898
1899 void
on_wire_tagnum_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)1900 on_wire_tagnum_spinbutton_value_changed
1901 (GtkSpinButton *spinbutton,
1902 gpointer user_data)
1903 {
1904 gtk_spin_button_update( spinbutton );
1905 Wire_Editor( EDITOR_TAGNUM );
1906 }
1907
1908
1909 void
on_wire_len_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)1910 on_wire_len_spinbutton_value_changed (GtkSpinButton *spinbutton,
1911 gpointer user_data)
1912 {
1913 gtk_spin_button_update( spinbutton );
1914 Wire_Editor( WIRE_EDITOR_WLEN );
1915 }
1916
1917
1918 void
on_wire_taper_checkbutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)1919 on_wire_taper_checkbutton_toggled (GtkToggleButton *togglebutton,
1920 gpointer user_data)
1921 {
1922 Wire_Editor( WIRE_EDITOR_TAPR );
1923 }
1924
1925
1926 void
on_wire_rlen_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)1927 on_wire_rlen_spinbutton_value_changed (GtkSpinButton *spinbutton,
1928 gpointer user_data)
1929 {
1930 gtk_spin_button_update( spinbutton );
1931 Wire_Editor( WIRE_EDITOR_RLEN );
1932 }
1933
1934
1935 void
on_wire_rdia_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)1936 on_wire_rdia_spinbutton_value_changed (GtkSpinButton *spinbutton,
1937 gpointer user_data)
1938 {
1939 gtk_spin_button_update( spinbutton );
1940 Wire_Editor( WIRE_EDITOR_RDIA );
1941 }
1942
1943
1944 void
on_wire_new_button_clicked(GtkButton * button,gpointer user_data)1945 on_wire_new_button_clicked (GtkButton *button,
1946 gpointer user_data)
1947 {
1948 Wire_Editor( EDITOR_NEW );
1949 }
1950
1951
1952 void
on_wire_res_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)1953 on_wire_res_spinbutton_value_changed (GtkSpinButton *spinbutton,
1954 gpointer user_data)
1955 {
1956 gtk_spin_button_update( spinbutton );
1957 Wire_Editor( EDITOR_LOAD );
1958 }
1959
1960
1961 void
on_wire_cancel_button_clicked(GtkButton * button,gpointer user_data)1962 on_wire_cancel_button_clicked (GtkButton *button,
1963 gpointer user_data)
1964 {
1965 Wire_Editor( EDITOR_CANCEL );
1966 gtk_widget_destroy( wire_editor );
1967 }
1968
1969
1970 void
on_wire_apply_button_clicked(GtkButton * button,gpointer user_data)1971 on_wire_apply_button_clicked (GtkButton *button,
1972 gpointer user_data)
1973 {
1974 Wire_Editor( EDITOR_APPLY );
1975 }
1976
1977
1978 void
on_wire_ok_button_clicked(GtkButton * button,gpointer user_data)1979 on_wire_ok_button_clicked (GtkButton *button,
1980 gpointer user_data)
1981 {
1982 Wire_Editor( EDITOR_APPLY );
1983 gtk_widget_destroy( wire_editor );
1984 }
1985
1986
1987 void
on_gw_clicked(GtkButton * button,gpointer user_data)1988 on_gw_clicked (GtkButton *button,
1989 gpointer user_data)
1990 {
1991 if( wire_editor == NULL )
1992 {
1993 wire_editor = create_wire_editor();
1994 gtk_widget_hide( lookup_widget(wire_editor, "wire_taperframe") );
1995 gtk_widget_show( wire_editor );
1996 }
1997 Wire_Editor( action );
1998 action = EDITOR_NEW;
1999 }
2000
2001
2002 void
on_ga_clicked(GtkButton * button,gpointer user_data)2003 on_ga_clicked (GtkButton *button,
2004 gpointer user_data)
2005 {
2006 if( arc_editor == NULL )
2007 {
2008 arc_editor = create_arc_editor();
2009 gtk_widget_show( arc_editor );
2010 }
2011 Arc_Editor( action );
2012 action = EDITOR_NEW;
2013 }
2014
2015
2016 void
on_gh_clicked(GtkButton * button,gpointer user_data)2017 on_gh_clicked (GtkButton *button,
2018 gpointer user_data)
2019 {
2020 if( helix_editor == NULL )
2021 {
2022 helix_editor = create_helix_editor();
2023 gtk_widget_show( helix_editor );
2024 }
2025 Helix_Editor( action );
2026 action = EDITOR_NEW;
2027 }
2028
2029
2030 void
on_sp_clicked(GtkButton * button,gpointer user_data)2031 on_sp_clicked (GtkButton *button,
2032 gpointer user_data)
2033 {
2034 if( patch_editor == NULL )
2035 {
2036 patch_editor = create_patch_editor();
2037 gtk_widget_show( patch_editor );
2038 }
2039 Patch_Editor( action );
2040 action = EDITOR_NEW;
2041 }
2042
2043
2044 void
on_gr_clicked(GtkButton * button,gpointer user_data)2045 on_gr_clicked (GtkButton *button,
2046 gpointer user_data)
2047 {
2048 if( cylinder_editor == NULL )
2049 {
2050 cylinder_editor = create_cylinder_editor();
2051 gtk_widget_show( cylinder_editor );
2052 }
2053 Cylinder_Editor( action );
2054 action = EDITOR_NEW;
2055 }
2056
2057
2058 void
on_gm_clicked(GtkButton * button,gpointer user_data)2059 on_gm_clicked (GtkButton *button,
2060 gpointer user_data)
2061 {
2062 if( transform_editor == NULL )
2063 {
2064 transform_editor = create_transform_editor();
2065 gtk_widget_show( transform_editor );
2066 }
2067 Transform_Editor( action );
2068 action = EDITOR_NEW;
2069 }
2070
2071
2072 void
on_gx_clicked(GtkButton * button,gpointer user_data)2073 on_gx_clicked (GtkButton *button,
2074 gpointer user_data)
2075 {
2076 if( reflect_editor == NULL )
2077 {
2078 reflect_editor = create_reflect_editor();
2079 gtk_widget_show( reflect_editor );
2080 }
2081 Reflect_Editor( action );
2082 action = EDITOR_NEW;
2083 }
2084
2085
2086 void
on_gs_clicked(GtkButton * button,gpointer user_data)2087 on_gs_clicked (GtkButton *button,
2088 gpointer user_data)
2089 {
2090 if( scale_editor == NULL )
2091 {
2092 scale_editor = create_scale_editor();
2093 gtk_widget_show( scale_editor );
2094 }
2095 Scale_Editor( action );
2096 action = EDITOR_NEW;
2097 }
2098
2099
2100 void
on_ex_clicked(GtkButton * button,gpointer user_data)2101 on_ex_clicked (GtkButton *button,
2102 gpointer user_data)
2103 {
2104 if( excitation_command == NULL )
2105 {
2106 excitation_command = create_excitation_command();
2107 gtk_widget_show( excitation_command );
2108 }
2109 Excitation_Command( action );
2110 action = EDITOR_NEW;
2111 }
2112
2113
2114 void
on_fr_clicked(GtkButton * button,gpointer user_data)2115 on_fr_clicked (GtkButton *button,
2116 gpointer user_data)
2117 {
2118 if( frequency_command == NULL )
2119 {
2120 frequency_command = create_frequency_command();
2121 gtk_widget_show( frequency_command );
2122 }
2123 Frequency_Command( action );
2124 action = EDITOR_NEW;
2125 }
2126
2127
2128 void
on_gn_clicked(GtkButton * button,gpointer user_data)2129 on_gn_clicked (GtkButton *button,
2130 gpointer user_data)
2131 {
2132 if( ground_command == NULL )
2133 {
2134 ground_command = create_ground_command();
2135 gtk_widget_show( ground_command );
2136 }
2137 Ground_Command( action );
2138 action = EDITOR_NEW;
2139 }
2140
2141
2142 void
on_gd_clicked(GtkButton * button,gpointer user_data)2143 on_gd_clicked (GtkButton *button,
2144 gpointer user_data)
2145 {
2146 if( ground2_command == NULL )
2147 {
2148 ground2_command = create_ground2_command();
2149 gtk_widget_show( ground2_command );
2150 }
2151 Ground2_Command( action );
2152 action = EDITOR_NEW;
2153 }
2154
2155
2156 void
on_rp_clicked(GtkButton * button,gpointer user_data)2157 on_rp_clicked (GtkButton *button,
2158 gpointer user_data)
2159 {
2160 if( radiation_command == NULL )
2161 {
2162 radiation_command = create_radiation_command();
2163 gtk_widget_show( radiation_command );
2164 }
2165 Radiation_Command( action );
2166 action = EDITOR_NEW;
2167 }
2168
2169
2170 void
on_ld_clicked(GtkButton * button,gpointer user_data)2171 on_ld_clicked (GtkButton *button,
2172 gpointer user_data)
2173 {
2174 if( loading_command == NULL )
2175 {
2176 loading_command = create_loading_command();
2177 gtk_widget_show( loading_command );
2178 }
2179 Loading_Command( action );
2180 action = EDITOR_NEW;
2181 }
2182
2183
2184 void
on_nt_clicked(GtkButton * button,gpointer user_data)2185 on_nt_clicked (GtkButton *button,
2186 gpointer user_data)
2187 {
2188 if( network_command == NULL )
2189 {
2190 network_command = create_network_command();
2191 gtk_widget_show( network_command );
2192 }
2193 Network_Command( action );
2194 action = EDITOR_NEW;
2195 }
2196
2197
2198 void
on_tl_clicked(GtkButton * button,gpointer user_data)2199 on_tl_clicked (GtkButton *button,
2200 gpointer user_data)
2201 {
2202 if( txline_command == NULL )
2203 {
2204 txline_command = create_txline_command();
2205 gtk_widget_show( txline_command );
2206 }
2207 Txline_Command( action );
2208 action = EDITOR_NEW;
2209 }
2210
2211
2212 void
on_ne_clicked(GtkButton * button,gpointer user_data)2213 on_ne_clicked (GtkButton *button,
2214 gpointer user_data)
2215 {
2216 if( nearfield_command == NULL )
2217 {
2218 nearfield_command = create_nearfield_command();
2219 gtk_widget_show( nearfield_command );
2220 }
2221 Nearfield_Command( action );
2222 action = EDITOR_NEW;
2223 }
2224
2225
2226 void
on_ek_clicked(GtkButton * button,gpointer user_data)2227 on_ek_clicked (GtkButton *button,
2228 gpointer user_data)
2229 {
2230 if( kernel_command == NULL )
2231 {
2232 kernel_command = create_kernel_command();
2233 gtk_widget_show( kernel_command );
2234 }
2235 Kernel_Command( action );
2236 action = EDITOR_NEW;
2237 }
2238
2239
2240 void
on_kh_clicked(GtkButton * button,gpointer user_data)2241 on_kh_clicked (GtkButton *button,
2242 gpointer user_data)
2243 {
2244 if( intrange_command == NULL )
2245 {
2246 intrange_command = create_intrange_command();
2247 gtk_widget_show( intrange_command );
2248 }
2249 Intrange_Command( action );
2250 action = EDITOR_NEW;
2251 }
2252
2253
2254 void
on_xq_clicked(GtkButton * button,gpointer user_data)2255 on_xq_clicked (GtkButton *button,
2256 gpointer user_data)
2257 {
2258 if( execute_command == NULL )
2259 {
2260 execute_command = create_execute_command();
2261 gtk_widget_show( execute_command );
2262 }
2263 Execute_Command( action );
2264 action = EDITOR_NEW;
2265 }
2266
2267
2268 void
on_patch_data_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2269 on_patch_data_spinbutton_value_changed (GtkSpinButton *spinbutton,
2270 gpointer user_data)
2271 {
2272 gtk_spin_button_update( spinbutton );
2273 Patch_Editor( EDITOR_DATA );
2274 }
2275
2276
2277 void
on_patch_new_button_clicked(GtkButton * button,gpointer user_data)2278 on_patch_new_button_clicked (GtkButton *button,
2279 gpointer user_data)
2280 {
2281 Patch_Editor( EDITOR_NEW );
2282 }
2283
2284
2285 void
on_patch_cancel_button_clicked(GtkButton * button,gpointer user_data)2286 on_patch_cancel_button_clicked (GtkButton *button,
2287 gpointer user_data)
2288 {
2289 Patch_Editor( EDITOR_CANCEL );
2290 gtk_widget_destroy( patch_editor );
2291 }
2292
2293
2294 void
on_patch_apply_button_clicked(GtkButton * button,gpointer user_data)2295 on_patch_apply_button_clicked (GtkButton *button,
2296 gpointer user_data)
2297 {
2298 Patch_Editor( EDITOR_APPLY );
2299 }
2300
2301
2302 void
on_patch_ok_button_clicked(GtkButton * button,gpointer user_data)2303 on_patch_ok_button_clicked (GtkButton *button,
2304 gpointer user_data)
2305 {
2306 Patch_Editor( EDITOR_APPLY );
2307 gtk_widget_destroy( patch_editor );
2308 }
2309
2310
2311 void
on_patch_editor_destroy(GtkObject * object,gpointer user_data)2312 on_patch_editor_destroy (GtkObject *object,
2313 gpointer user_data)
2314 {
2315 patch_editor = NULL;
2316 }
2317
2318
2319 void
on_patch_arbitrary_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2320 on_patch_arbitrary_radiobutton_toggled (GtkToggleButton *togglebutton,
2321 gpointer user_data)
2322 {
2323 if( gtk_toggle_button_get_active(togglebutton) )
2324 Patch_Editor( PATCH_EDITOR_ARBT );
2325 else
2326 Patch_Editor( PATCH_EDITOR_SCCD );
2327 }
2328
2329
2330 void
on_patch_rectangular_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2331 on_patch_rectangular_radiobutton_toggled
2332 (GtkToggleButton *togglebutton,
2333 gpointer user_data)
2334 {
2335 if( gtk_toggle_button_get_active(togglebutton) )
2336 Patch_Editor( PATCH_EDITOR_RECT );
2337 }
2338
2339
2340 void
on_patch_triangular_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2341 on_patch_triangular_radiobutton_toggled
2342 (GtkToggleButton *togglebutton,
2343 gpointer user_data)
2344 {
2345 if( gtk_toggle_button_get_active(togglebutton) )
2346 Patch_Editor( PATCH_EDITOR_TRIA );
2347 }
2348
2349
2350 void
on_patch_quadrilateral_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2351 on_patch_quadrilateral_radiobutton_toggled
2352 (GtkToggleButton *togglebutton,
2353 gpointer user_data)
2354 {
2355 if( gtk_toggle_button_get_active(togglebutton) )
2356 Patch_Editor( PATCH_EDITOR_QUAD );
2357 }
2358
2359
2360 void
on_patch_surface_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2361 on_patch_surface_radiobutton_toggled (GtkToggleButton *togglebutton,
2362 gpointer user_data)
2363 {
2364 if( gtk_toggle_button_get_active(togglebutton) )
2365 Patch_Editor( PATCH_EDITOR_SURF );
2366 }
2367
2368
2369 void
on_arc_data_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2370 on_arc_data_spinbutton_value_changed (GtkSpinButton *spinbutton,
2371 gpointer user_data)
2372 {
2373 gtk_spin_button_update( spinbutton );
2374 Arc_Editor( EDITOR_DATA );
2375 }
2376
2377
2378 void
on_arc_tagnum_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2379 on_arc_tagnum_spinbutton_value_changed (GtkSpinButton *spinbutton,
2380 gpointer user_data)
2381 {
2382 gtk_spin_button_update( spinbutton );
2383 Arc_Editor( EDITOR_TAGNUM );
2384 }
2385
2386
2387 void
on_arc_res_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2388 on_arc_res_spinbutton_value_changed (GtkSpinButton *spinbutton,
2389 gpointer user_data)
2390 {
2391 gtk_spin_button_update( spinbutton );
2392 Arc_Editor( EDITOR_LOAD );
2393 }
2394
2395
2396 void
on_arc_new_button_clicked(GtkButton * button,gpointer user_data)2397 on_arc_new_button_clicked (GtkButton *button,
2398 gpointer user_data)
2399 {
2400 Arc_Editor( EDITOR_NEW );
2401 }
2402
2403
2404 void
on_arc_cancel_button_clicked(GtkButton * button,gpointer user_data)2405 on_arc_cancel_button_clicked (GtkButton *button,
2406 gpointer user_data)
2407 {
2408 Arc_Editor( EDITOR_CANCEL );
2409 gtk_widget_destroy( arc_editor );
2410 }
2411
2412
2413 void
on_arc_apply_button_clicked(GtkButton * button,gpointer user_data)2414 on_arc_apply_button_clicked (GtkButton *button,
2415 gpointer user_data)
2416 {
2417 Arc_Editor( EDITOR_APPLY );
2418 }
2419
2420
2421 void
on_arc_ok_button_clicked(GtkButton * button,gpointer user_data)2422 on_arc_ok_button_clicked (GtkButton *button,
2423 gpointer user_data)
2424 {
2425 Arc_Editor( EDITOR_APPLY );
2426 gtk_widget_destroy( arc_editor );
2427 }
2428
2429
2430 void
on_arc_editor_destroy(GtkObject * object,gpointer user_data)2431 on_arc_editor_destroy (GtkObject *object,
2432 gpointer user_data)
2433 {
2434 arc_editor = NULL;
2435 }
2436
2437
2438 void
on_arc_pcl_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2439 on_arc_pcl_spinbutton_value_changed (GtkSpinButton *spinbutton,
2440 gpointer user_data)
2441 {
2442 gtk_spin_button_update( spinbutton );
2443 Arc_Editor( EDITOR_SEGPC );
2444 }
2445
2446
2447 void
on_helix_tagnum_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2448 on_helix_tagnum_spinbutton_value_changed
2449 (GtkSpinButton *spinbutton,
2450 gpointer user_data)
2451 {
2452 gtk_spin_button_update( spinbutton );
2453 Helix_Editor( EDITOR_TAGNUM );
2454 }
2455
2456
2457 void
on_helix_pcl_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2458 on_helix_pcl_spinbutton_value_changed (GtkSpinButton *spinbutton,
2459 gpointer user_data)
2460 {
2461 gtk_spin_button_update( spinbutton );
2462 Helix_Editor( EDITOR_SEGPC );
2463 }
2464
2465
2466 void
on_helix_nturns_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2467 on_helix_nturns_spinbutton_value_changed
2468 (GtkSpinButton *spinbutton,
2469 gpointer user_data)
2470 {
2471 gtk_spin_button_update( spinbutton );
2472 Helix_Editor( HELIX_EDITOR_NTURN );
2473 }
2474
2475
2476 void
on_helix_res_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2477 on_helix_res_spinbutton_value_changed (GtkSpinButton *spinbutton,
2478 gpointer user_data)
2479 {
2480 gtk_spin_button_update( spinbutton );
2481 Helix_Editor( EDITOR_LOAD );
2482 }
2483
2484
2485 void
on_helix_lh_checkbutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2486 on_helix_lh_checkbutton_toggled (GtkToggleButton *togglebutton,
2487 gpointer user_data)
2488 {
2489 if( gtk_toggle_button_get_active(togglebutton) )
2490 Helix_Editor( HELIX_EDITOR_LH );
2491 else
2492 Helix_Editor( HELIX_EDITOR_RH );
2493 }
2494
2495
2496 void
on_helix_data_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2497 on_helix_data_spinbutton_value_changed (GtkSpinButton *spinbutton,
2498 gpointer user_data)
2499 {
2500 gtk_spin_button_update( spinbutton );
2501 Helix_Editor( EDITOR_DATA );
2502 }
2503
2504
2505 void
on_helix_new_button_clicked(GtkButton * button,gpointer user_data)2506 on_helix_new_button_clicked (GtkButton *button,
2507 gpointer user_data)
2508 {
2509 Helix_Editor( EDITOR_NEW );
2510 }
2511
2512
2513 void
on_helix_cancel_button_clicked(GtkButton * button,gpointer user_data)2514 on_helix_cancel_button_clicked (GtkButton *button,
2515 gpointer user_data)
2516 {
2517 Helix_Editor( EDITOR_CANCEL );
2518 gtk_widget_destroy( helix_editor );
2519 }
2520
2521
2522 void
on_helix_apply_button_clicked(GtkButton * button,gpointer user_data)2523 on_helix_apply_button_clicked (GtkButton *button,
2524 gpointer user_data)
2525 {
2526 Helix_Editor( EDITOR_APPLY );
2527 }
2528
2529
2530 void
on_helix_ok_button_clicked(GtkButton * button,gpointer user_data)2531 on_helix_ok_button_clicked (GtkButton *button,
2532 gpointer user_data)
2533 {
2534 Helix_Editor( EDITOR_APPLY );
2535 gtk_widget_destroy( helix_editor );
2536 }
2537
2538
2539 void
on_helix_editor_destroy(GtkObject * object,gpointer user_data)2540 on_helix_editor_destroy (GtkObject *object,
2541 gpointer user_data)
2542 {
2543 helix_editor = NULL;
2544 }
2545
2546
2547 void
on_helix_linkall_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2548 on_helix_linkall_radiobutton_toggled (GtkToggleButton *togglebutton,
2549 gpointer user_data)
2550 {
2551 if( gtk_toggle_button_get_active(togglebutton) )
2552 Helix_Editor( HELIX_EDITOR_LINKALL );
2553 }
2554
2555
2556 void
on_helix_linkzo_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2557 on_helix_linkzo_radiobutton_toggled (GtkToggleButton *togglebutton,
2558 gpointer user_data)
2559 {
2560 if( gtk_toggle_button_get_active(togglebutton) )
2561 Helix_Editor( HELIX_EDITOR_LINKZO );
2562 }
2563
2564
2565 void
on_helix_linkzhl_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2566 on_helix_linkzhl_radiobutton_toggled (GtkToggleButton *togglebutton,
2567 gpointer user_data)
2568 {
2569 if( gtk_toggle_button_get_active(togglebutton) )
2570 Helix_Editor( HELIX_EDITOR_LINKZHL );
2571 }
2572
2573
2574 void
on_reflect_taginc_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2575 on_reflect_taginc_spinbutton_value_changed
2576 (GtkSpinButton *spinbutton,
2577 gpointer user_data)
2578 {
2579 gtk_spin_button_update( spinbutton );
2580 Reflect_Editor( EDITOR_DATA );
2581 }
2582
2583
2584 void
on_reflect_checkbutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2585 on_reflect_checkbutton_toggled (GtkToggleButton *togglebutton,
2586 gpointer user_data)
2587 {
2588 Reflect_Editor( REFLECT_EDITOR_TOGGLE );
2589 }
2590
2591
2592 void
on_reflect_new_button_clicked(GtkButton * button,gpointer user_data)2593 on_reflect_new_button_clicked (GtkButton *button,
2594 gpointer user_data)
2595 {
2596 Reflect_Editor( EDITOR_NEW );
2597 }
2598
2599
2600 void
on_reflect_cancel_button_clicked(GtkButton * button,gpointer user_data)2601 on_reflect_cancel_button_clicked (GtkButton *button,
2602 gpointer user_data)
2603 {
2604 Reflect_Editor( EDITOR_CANCEL );
2605 gtk_widget_destroy( reflect_editor );
2606 }
2607
2608
2609 void
on_reflect_apply_button_clicked(GtkButton * button,gpointer user_data)2610 on_reflect_apply_button_clicked (GtkButton *button,
2611 gpointer user_data)
2612 {
2613 Reflect_Editor( EDITOR_APPLY );
2614 }
2615
2616
2617 void
on_reflect_ok_button_clicked(GtkButton * button,gpointer user_data)2618 on_reflect_ok_button_clicked (GtkButton *button,
2619 gpointer user_data)
2620 {
2621 Reflect_Editor( EDITOR_APPLY );
2622 gtk_widget_destroy( reflect_editor );
2623 }
2624
2625
2626 void
on_reflect_editor_destroy(GtkObject * object,gpointer user_data)2627 on_reflect_editor_destroy (GtkObject *object,
2628 gpointer user_data)
2629 {
2630 reflect_editor = NULL;
2631 }
2632
2633
2634 void
on_scale_editor_destroy(GtkObject * object,gpointer user_data)2635 on_scale_editor_destroy (GtkObject *object,
2636 gpointer user_data)
2637 {
2638 scale_editor = NULL;
2639 }
2640
2641
2642 void
on_scale_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2643 on_scale_spinbutton_value_changed (GtkSpinButton *spinbutton,
2644 gpointer user_data)
2645 {
2646 gtk_spin_button_update( spinbutton );
2647 Scale_Editor( EDITOR_DATA );
2648 }
2649
2650
2651
2652 void
on_scale_new_button_clicked(GtkButton * button,gpointer user_data)2653 on_scale_new_button_clicked (GtkButton *button,
2654 gpointer user_data)
2655 {
2656 Scale_Editor( EDITOR_NEW );
2657 }
2658
2659
2660 void
on_scale_cancel_button_clicked(GtkButton * button,gpointer user_data)2661 on_scale_cancel_button_clicked (GtkButton *button,
2662 gpointer user_data)
2663 {
2664 Scale_Editor( EDITOR_CANCEL );
2665 gtk_widget_destroy( scale_editor );
2666 }
2667
2668
2669 void
on_scale_apply_button_clicked(GtkButton * button,gpointer user_data)2670 on_scale_apply_button_clicked (GtkButton *button,
2671 gpointer user_data)
2672 {
2673 Scale_Editor( EDITOR_APPLY );
2674 }
2675
2676
2677 void
on_scale_ok_button_clicked(GtkButton * button,gpointer user_data)2678 on_scale_ok_button_clicked (GtkButton *button,
2679 gpointer user_data)
2680 {
2681 Scale_Editor( EDITOR_APPLY );
2682 gtk_widget_destroy( scale_editor );
2683 }
2684
2685
2686 void
on_cylinder_taginc_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2687 on_cylinder_taginc_spinbutton_value_changed
2688 (GtkSpinButton *spinbutton,
2689 gpointer user_data)
2690 {
2691 gtk_spin_button_update( spinbutton );
2692 Cylinder_Editor( EDITOR_DATA );
2693 }
2694
2695
2696 void
on_cylinder_total_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2697 on_cylinder_total_spinbutton_value_changed
2698 (GtkSpinButton *spinbutton,
2699 gpointer user_data)
2700 {
2701 gtk_spin_button_update( spinbutton );
2702 Cylinder_Editor( EDITOR_DATA );
2703 }
2704
2705
2706 void
on_cylinder_new_button_clicked(GtkButton * button,gpointer user_data)2707 on_cylinder_new_button_clicked (GtkButton *button,
2708 gpointer user_data)
2709 {
2710 Cylinder_Editor( EDITOR_NEW );
2711 }
2712
2713
2714 void
on_cylinder_cancel_button_clicked(GtkButton * button,gpointer user_data)2715 on_cylinder_cancel_button_clicked (GtkButton *button,
2716 gpointer user_data)
2717 {
2718 Cylinder_Editor( EDITOR_CANCEL );
2719 gtk_widget_destroy( cylinder_editor );
2720 }
2721
2722
2723 void
on_cylinder_apply_button_clicked(GtkButton * button,gpointer user_data)2724 on_cylinder_apply_button_clicked (GtkButton *button,
2725 gpointer user_data)
2726 {
2727 Cylinder_Editor( EDITOR_APPLY );
2728 }
2729
2730
2731 void
on_cylinder_ok_button_clicked(GtkButton * button,gpointer user_data)2732 on_cylinder_ok_button_clicked (GtkButton *button,
2733 gpointer user_data)
2734 {
2735 Cylinder_Editor( EDITOR_APPLY );
2736 gtk_widget_destroy( cylinder_editor );
2737 }
2738
2739
2740 void
on_cylinder_editor_destroy(GtkObject * object,gpointer user_data)2741 on_cylinder_editor_destroy (GtkObject *object,
2742 gpointer user_data)
2743 {
2744 cylinder_editor = NULL;
2745 }
2746
2747
2748 void
on_transform_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2749 on_transform_spinbutton_value_changed (GtkSpinButton *spinbutton,
2750 gpointer user_data)
2751 {
2752 gtk_spin_button_update( spinbutton );
2753 Transform_Editor( EDITOR_DATA );
2754 }
2755
2756
2757 void
on_transform_new_button_clicked(GtkButton * button,gpointer user_data)2758 on_transform_new_button_clicked (GtkButton *button,
2759 gpointer user_data)
2760 {
2761 Transform_Editor( EDITOR_NEW );
2762 }
2763
2764
2765 void
on_transform_cancel_button_clicked(GtkButton * button,gpointer user_data)2766 on_transform_cancel_button_clicked (GtkButton *button,
2767 gpointer user_data)
2768 {
2769 Transform_Editor( EDITOR_CANCEL );
2770 gtk_widget_destroy( transform_editor );
2771 }
2772
2773
2774 void
on_transform_apply_button_clicked(GtkButton * button,gpointer user_data)2775 on_transform_apply_button_clicked (GtkButton *button,
2776 gpointer user_data)
2777 {
2778 Transform_Editor( EDITOR_APPLY );
2779 }
2780
2781
2782 void
on_transform_ok_button_clicked(GtkButton * button,gpointer user_data)2783 on_transform_ok_button_clicked (GtkButton *button,
2784 gpointer user_data)
2785 {
2786 Transform_Editor( EDITOR_APPLY );
2787 gtk_widget_destroy( transform_editor );
2788 }
2789
2790
2791 void
on_transform_editor_destroy(GtkObject * object,gpointer user_data)2792 on_transform_editor_destroy (GtkObject *object,
2793 gpointer user_data)
2794 {
2795 transform_editor = NULL;
2796 }
2797
2798
2799
2800 void
on_gend_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2801 on_gend_radiobutton_toggled (GtkToggleButton *togglebutton,
2802 gpointer user_data)
2803 {
2804 Gend_Editor( EDITOR_RDBUTTON );
2805 }
2806
2807
2808 void
on_gend_cancel_button_clicked(GtkButton * button,gpointer user_data)2809 on_gend_cancel_button_clicked (GtkButton *button,
2810 gpointer user_data)
2811 {
2812 Gend_Editor( EDITOR_CANCEL );
2813 gtk_widget_destroy( gend_editor );
2814 }
2815
2816
2817 void
on_gend_apply_button_clicked(GtkButton * button,gpointer user_data)2818 on_gend_apply_button_clicked (GtkButton *button,
2819 gpointer user_data)
2820 {
2821 Gend_Editor( EDITOR_APPLY );
2822 }
2823
2824
2825 void
on_gend_ok_button_clicked(GtkButton * button,gpointer user_data)2826 on_gend_ok_button_clicked (GtkButton *button,
2827 gpointer user_data)
2828 {
2829 Gend_Editor( EDITOR_APPLY );
2830 gtk_widget_destroy( gend_editor );
2831 }
2832
2833
2834 void
on_gend_editor_destroy(GtkObject * object,gpointer user_data)2835 on_gend_editor_destroy (GtkObject *object,
2836 gpointer user_data)
2837 {
2838 gend_editor = NULL;
2839 }
2840
2841
2842 void
on_kernel_command_destroy(GtkObject * object,gpointer user_data)2843 on_kernel_command_destroy (GtkObject *object,
2844 gpointer user_data)
2845 {
2846 kernel_command = NULL;
2847 }
2848
2849
2850 void
on_kernel_checkbutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2851 on_kernel_checkbutton_toggled (GtkToggleButton *togglebutton,
2852 gpointer user_data)
2853 {
2854 Kernel_Command( COMMAND_CKBUTTON );
2855 }
2856
2857
2858 void
on_kernel_new_button_clicked(GtkButton * button,gpointer user_data)2859 on_kernel_new_button_clicked (GtkButton *button,
2860 gpointer user_data)
2861 {
2862 Kernel_Command( EDITOR_NEW );
2863 }
2864
2865
2866 void
on_kernel_cancel_button_clicked(GtkButton * button,gpointer user_data)2867 on_kernel_cancel_button_clicked (GtkButton *button,
2868 gpointer user_data)
2869 {
2870 Kernel_Command( EDITOR_CANCEL );
2871 gtk_widget_destroy( kernel_command );
2872 }
2873
2874
2875 void
on_kernel_apply_button_clicked(GtkButton * button,gpointer user_data)2876 on_kernel_apply_button_clicked (GtkButton *button,
2877 gpointer user_data)
2878 {
2879 Kernel_Command( EDITOR_APPLY );
2880 }
2881
2882
2883 void
on_kernel_ok_button_clicked(GtkButton * button,gpointer user_data)2884 on_kernel_ok_button_clicked (GtkButton *button,
2885 gpointer user_data)
2886 {
2887 Kernel_Command( EDITOR_APPLY );
2888 gtk_widget_destroy( kernel_command );
2889 }
2890
2891
2892 void
on_execute_command_destroy(GtkObject * object,gpointer user_data)2893 on_execute_command_destroy (GtkObject *object,
2894 gpointer user_data)
2895 {
2896 execute_command = NULL;
2897 }
2898
2899
2900 void
on_execute_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)2901 on_execute_radiobutton_toggled (GtkToggleButton *togglebutton,
2902 gpointer user_data)
2903 {
2904 Execute_Command( COMMAND_RDBUTTON );
2905 }
2906
2907
2908 void
on_execute_new_button_clicked(GtkButton * button,gpointer user_data)2909 on_execute_new_button_clicked (GtkButton *button,
2910 gpointer user_data)
2911 {
2912 Execute_Command( EDITOR_NEW );
2913 }
2914
2915
2916 void
on_execute_cancel_button_clicked(GtkButton * button,gpointer user_data)2917 on_execute_cancel_button_clicked (GtkButton *button,
2918 gpointer user_data)
2919 {
2920 Execute_Command( EDITOR_CANCEL );
2921 gtk_widget_destroy( execute_command );
2922 }
2923
2924
2925 void
on_execute_apply_button_clicked(GtkButton * button,gpointer user_data)2926 on_execute_apply_button_clicked (GtkButton *button,
2927 gpointer user_data)
2928 {
2929 Execute_Command( EDITOR_APPLY );
2930 }
2931
2932
2933 void
on_execute_ok_button_clicked(GtkButton * button,gpointer user_data)2934 on_execute_ok_button_clicked (GtkButton *button,
2935 gpointer user_data)
2936 {
2937 Execute_Command( EDITOR_APPLY );
2938 gtk_widget_destroy( execute_command );
2939 }
2940
2941
2942 void
on_intrange_command_destroy(GtkObject * object,gpointer user_data)2943 on_intrange_command_destroy (GtkObject *object,
2944 gpointer user_data)
2945 {
2946 intrange_command = NULL;
2947 }
2948
2949
2950 void
on_intrange_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)2951 on_intrange_spinbutton_value_changed (GtkSpinButton *spinbutton,
2952 gpointer user_data)
2953 {
2954 gtk_spin_button_update( spinbutton );
2955 Intrange_Command( EDITOR_DATA );
2956 }
2957
2958
2959 void
on_intrange_new_button_clicked(GtkButton * button,gpointer user_data)2960 on_intrange_new_button_clicked (GtkButton *button,
2961 gpointer user_data)
2962 {
2963 Intrange_Command( EDITOR_NEW );
2964 }
2965
2966
2967 void
on_intrange_cancel_button_clicked(GtkButton * button,gpointer user_data)2968 on_intrange_cancel_button_clicked (GtkButton *button,
2969 gpointer user_data)
2970 {
2971 Intrange_Command( EDITOR_CANCEL );
2972 gtk_widget_destroy( intrange_command );
2973 }
2974
2975
2976 void
on_intrange_apply_button_clicked(GtkButton * button,gpointer user_data)2977 on_intrange_apply_button_clicked (GtkButton *button,
2978 gpointer user_data)
2979 {
2980 Intrange_Command( EDITOR_APPLY );
2981 }
2982
2983
2984 void
on_intrange_ok_button_clicked(GtkButton * button,gpointer user_data)2985 on_intrange_ok_button_clicked (GtkButton *button,
2986 gpointer user_data)
2987 {
2988 Intrange_Command( EDITOR_APPLY );
2989 gtk_widget_destroy( intrange_command );
2990 }
2991
2992
2993 void
on_ground_command_destroy(GtkObject * object,gpointer user_data)2994 on_ground_command_destroy (GtkObject *object,
2995 gpointer user_data)
2996 {
2997 ground_command = NULL;
2998 }
2999
3000
3001 void
on_ground_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3002 on_ground_radiobutton_toggled (GtkToggleButton *togglebutton,
3003 gpointer user_data)
3004 {
3005 Ground_Command( COMMAND_RDBUTTON );
3006 }
3007
3008
3009 void
on_ground_checkbutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3010 on_ground_checkbutton_toggled (GtkToggleButton *togglebutton,
3011 gpointer user_data)
3012 {
3013 Ground_Command( COMMAND_CKBUTTON );
3014 }
3015
3016
3017 void
on_ground_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3018 on_ground_spinbutton_value_changed (GtkSpinButton *spinbutton,
3019 gpointer user_data)
3020 {
3021 gtk_spin_button_update( spinbutton );
3022 Ground_Command( EDITOR_DATA );
3023 }
3024
3025
3026 void
on_ground_new_button_clicked(GtkButton * button,gpointer user_data)3027 on_ground_new_button_clicked (GtkButton *button,
3028 gpointer user_data)
3029 {
3030 Ground_Command( EDITOR_NEW );
3031 }
3032
3033
3034 void
on_ground_cancel_button_clicked(GtkButton * button,gpointer user_data)3035 on_ground_cancel_button_clicked (GtkButton *button,
3036 gpointer user_data)
3037 {
3038 Ground_Command( EDITOR_CANCEL );
3039 gtk_widget_destroy( ground_command );
3040 }
3041
3042
3043 void
on_ground_apply_button_clicked(GtkButton * button,gpointer user_data)3044 on_ground_apply_button_clicked (GtkButton *button,
3045 gpointer user_data)
3046 {
3047 Ground_Command( EDITOR_APPLY );
3048 }
3049
3050
3051 void
on_ground_ok_button_clicked(GtkButton * button,gpointer user_data)3052 on_ground_ok_button_clicked (GtkButton *button,
3053 gpointer user_data)
3054 {
3055 Ground_Command( EDITOR_APPLY );
3056 gtk_widget_destroy( ground_command );
3057 }
3058
3059
3060 void
on_nearfield_command_destroy(GtkObject * object,gpointer user_data)3061 on_nearfield_command_destroy (GtkObject *object,
3062 gpointer user_data)
3063 {
3064 nearfield_command = NULL;
3065 }
3066
3067
3068
3069 void
on_nearfield_nh_checkbutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3070 on_nearfield_nh_checkbutton_toggled (GtkToggleButton *togglebutton,
3071 gpointer user_data)
3072 {
3073 Nearfield_Command( NEARFIELD_NH_CKBUTTON );
3074 }
3075
3076
3077 void
on_nearfield_ne_checkbutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3078 on_nearfield_ne_checkbutton_toggled (GtkToggleButton *togglebutton,
3079 gpointer user_data)
3080 {
3081 Nearfield_Command( NEARFIELD_NE_CKBUTTON );
3082 }
3083
3084
3085 void
on_nearfield_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3086 on_nearfield_radiobutton_toggled (GtkToggleButton *togglebutton,
3087 gpointer user_data)
3088 {
3089 Nearfield_Command( COMMAND_RDBUTTON );
3090 }
3091
3092
3093 void
on_nearfield_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3094 on_nearfield_spinbutton_value_changed (GtkSpinButton *spinbutton,
3095 gpointer user_data)
3096 {
3097 gtk_spin_button_update( spinbutton );
3098 Nearfield_Command( EDITOR_DATA );
3099 }
3100
3101
3102 void
on_nearfield_new_button_clicked(GtkButton * button,gpointer user_data)3103 on_nearfield_new_button_clicked (GtkButton *button,
3104 gpointer user_data)
3105 {
3106 Nearfield_Command( EDITOR_NEW );
3107 }
3108
3109
3110 void
on_nearfield_cancel_button_clicked(GtkButton * button,gpointer user_data)3111 on_nearfield_cancel_button_clicked (GtkButton *button,
3112 gpointer user_data)
3113 {
3114 Nearfield_Command( EDITOR_CANCEL );
3115 gtk_widget_destroy( nearfield_command );
3116 }
3117
3118
3119 void
on_nearfield_apply_button_clicked(GtkButton * button,gpointer user_data)3120 on_nearfield_apply_button_clicked (GtkButton *button,
3121 gpointer user_data)
3122 {
3123 Nearfield_Command( EDITOR_APPLY );
3124 }
3125
3126
3127 void
on_nearfield_ok_button_clicked(GtkButton * button,gpointer user_data)3128 on_nearfield_ok_button_clicked (GtkButton *button,
3129 gpointer user_data)
3130 {
3131 Nearfield_Command( EDITOR_APPLY );
3132 gtk_widget_destroy( nearfield_command );
3133 }
3134
3135
3136 void
on_radiation_command_destroy(GtkObject * object,gpointer user_data)3137 on_radiation_command_destroy (GtkObject *object,
3138 gpointer user_data)
3139 {
3140 radiation_command = NULL;
3141 }
3142
3143
3144 void
on_radiation_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3145 on_radiation_radiobutton_toggled (GtkToggleButton *togglebutton,
3146 gpointer user_data)
3147 {
3148 Radiation_Command( COMMAND_RDBUTTON );
3149 }
3150
3151
3152 void
on_radiation_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3153 on_radiation_spinbutton_value_changed (GtkSpinButton *spinbutton,
3154 gpointer user_data)
3155 {
3156 gtk_spin_button_update( spinbutton );
3157 Radiation_Command( EDITOR_DATA );
3158 }
3159
3160
3161 void
on_radiation_new_button_clicked(GtkButton * button,gpointer user_data)3162 on_radiation_new_button_clicked (GtkButton *button,
3163 gpointer user_data)
3164 {
3165 Radiation_Command( EDITOR_NEW );
3166 }
3167
3168
3169 void
on_radiation_cancel_button_clicked(GtkButton * button,gpointer user_data)3170 on_radiation_cancel_button_clicked (GtkButton *button,
3171 gpointer user_data)
3172 {
3173 Radiation_Command( EDITOR_CANCEL );
3174 gtk_widget_destroy( radiation_command );
3175 }
3176
3177
3178 void
on_radiation_apply_button_clicked(GtkButton * button,gpointer user_data)3179 on_radiation_apply_button_clicked (GtkButton *button,
3180 gpointer user_data)
3181 {
3182 Radiation_Command( EDITOR_APPLY );
3183 }
3184
3185
3186 void
on_radiation_ok_button_clicked(GtkButton * button,gpointer user_data)3187 on_radiation_ok_button_clicked (GtkButton *button,
3188 gpointer user_data)
3189 {
3190 Radiation_Command( EDITOR_APPLY );
3191 gtk_widget_destroy( radiation_command );
3192 }
3193
3194
3195 void
on_excitation_command_destroy(GtkObject * object,gpointer user_data)3196 on_excitation_command_destroy (GtkObject *object,
3197 gpointer user_data)
3198 {
3199 excitation_command = NULL;
3200 }
3201
3202
3203 void
on_excitation_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3204 on_excitation_radiobutton_toggled (GtkToggleButton *togglebutton,
3205 gpointer user_data)
3206 {
3207 Excitation_Command( COMMAND_RDBUTTON );
3208 }
3209
3210
3211 void
on_excitation_checkbutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3212 on_excitation_checkbutton_toggled (GtkToggleButton *togglebutton,
3213 gpointer user_data)
3214 {
3215 Excitation_Command( COMMAND_CKBUTTON );
3216 }
3217
3218
3219 void
on_excitation_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3220 on_excitation_spinbutton_value_changed (GtkSpinButton *spinbutton,
3221 gpointer user_data)
3222 {
3223 gtk_spin_button_update( spinbutton );
3224 Excitation_Command( EDITOR_DATA );
3225 }
3226
3227
3228 void
on_excitation_new_button_clicked(GtkButton * button,gpointer user_data)3229 on_excitation_new_button_clicked (GtkButton *button,
3230 gpointer user_data)
3231 {
3232 Excitation_Command( EDITOR_NEW );
3233 }
3234
3235
3236 void
on_excitation_cancel_button_clicked(GtkButton * button,gpointer user_data)3237 on_excitation_cancel_button_clicked (GtkButton *button,
3238 gpointer user_data)
3239 {
3240 Excitation_Command( EDITOR_CANCEL );
3241 gtk_widget_destroy( excitation_command );
3242 }
3243
3244
3245 void
on_excitation_apply_button_clicked(GtkButton * button,gpointer user_data)3246 on_excitation_apply_button_clicked (GtkButton *button,
3247 gpointer user_data)
3248 {
3249 Excitation_Command( EDITOR_APPLY );
3250 }
3251
3252
3253 void
on_excitation_ok_button_clicked(GtkButton * button,gpointer user_data)3254 on_excitation_ok_button_clicked (GtkButton *button,
3255 gpointer user_data)
3256 {
3257 Excitation_Command( EDITOR_APPLY );
3258 gtk_widget_destroy( excitation_command );
3259 }
3260
3261
3262 void
on_frequency_command_destroy(GtkObject * object,gpointer user_data)3263 on_frequency_command_destroy (GtkObject *object,
3264 gpointer user_data)
3265 {
3266 frequency_command = NULL;
3267 }
3268
3269
3270 void
on_frequency_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3271 on_frequency_radiobutton_toggled (GtkToggleButton *togglebutton,
3272 gpointer user_data)
3273 {
3274 Frequency_Command( COMMAND_RDBUTTON );
3275 }
3276
3277
3278 void
on_frequency_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3279 on_frequency_spinbutton_value_changed (GtkSpinButton *spinbutton,
3280 gpointer user_data)
3281 {
3282 gtk_spin_button_update( spinbutton );
3283 Frequency_Command( EDITOR_DATA );
3284 }
3285
3286
3287 void
on_frequency_step_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3288 on_frequency_step_spinbutton_value_changed
3289 (GtkSpinButton *spinbutton,
3290 gpointer user_data)
3291 {
3292 gtk_spin_button_update( spinbutton );
3293 Frequency_Command( FREQUENCY_EDITOR_FSTEP );
3294 }
3295
3296
3297 void
on_frequency_new_button_clicked(GtkButton * button,gpointer user_data)3298 on_frequency_new_button_clicked (GtkButton *button,
3299 gpointer user_data)
3300 {
3301 Frequency_Command( EDITOR_NEW );
3302 }
3303
3304
3305 void
on_frequency_cancel_button_clicked(GtkButton * button,gpointer user_data)3306 on_frequency_cancel_button_clicked (GtkButton *button,
3307 gpointer user_data)
3308 {
3309 Frequency_Command( EDITOR_CANCEL );
3310 gtk_widget_destroy( frequency_command );
3311 }
3312
3313
3314 void
on_frequency_apply_button_clicked(GtkButton * button,gpointer user_data)3315 on_frequency_apply_button_clicked (GtkButton *button,
3316 gpointer user_data)
3317 {
3318 Frequency_Command( EDITOR_APPLY );
3319 }
3320
3321
3322 void
on_frequency_ok_button_clicked(GtkButton * button,gpointer user_data)3323 on_frequency_ok_button_clicked (GtkButton *button,
3324 gpointer user_data)
3325 {
3326 Frequency_Command( EDITOR_APPLY );
3327 gtk_widget_destroy( frequency_command );
3328 }
3329
3330
3331 void
on_loading_command_destroy(GtkObject * object,gpointer user_data)3332 on_loading_command_destroy (GtkObject *object,
3333 gpointer user_data)
3334 {
3335 loading_command = NULL;
3336 }
3337
3338
3339 void
on_loading_radiobutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3340 on_loading_radiobutton_toggled (GtkToggleButton *togglebutton,
3341 gpointer user_data)
3342 {
3343 Loading_Command( COMMAND_RDBUTTON );
3344 }
3345
3346
3347 void
on_loading_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3348 on_loading_spinbutton_value_changed (GtkSpinButton *spinbutton,
3349 gpointer user_data)
3350 {
3351 gtk_spin_button_update( spinbutton );
3352 Loading_Command( EDITOR_DATA );
3353 }
3354
3355
3356 void
on_loading_new_button_clicked(GtkButton * button,gpointer user_data)3357 on_loading_new_button_clicked (GtkButton *button,
3358 gpointer user_data)
3359 {
3360 Loading_Command( EDITOR_NEW );
3361 }
3362
3363
3364 void
on_loading_cancel_button_clicked(GtkButton * button,gpointer user_data)3365 on_loading_cancel_button_clicked (GtkButton *button,
3366 gpointer user_data)
3367 {
3368 Loading_Command( EDITOR_CANCEL );
3369 gtk_widget_destroy( loading_command );
3370 }
3371
3372
3373 void
on_loading_apply_button_clicked(GtkButton * button,gpointer user_data)3374 on_loading_apply_button_clicked (GtkButton *button,
3375 gpointer user_data)
3376 {
3377 Loading_Command( EDITOR_APPLY );
3378 }
3379
3380
3381 void
on_loading_ok_button_clicked(GtkButton * button,gpointer user_data)3382 on_loading_ok_button_clicked (GtkButton *button,
3383 gpointer user_data)
3384 {
3385 Loading_Command( EDITOR_APPLY );
3386 gtk_widget_destroy( loading_command );
3387 }
3388
3389
3390 void
on_network_command_destroy(GtkObject * object,gpointer user_data)3391 on_network_command_destroy (GtkObject *object,
3392 gpointer user_data)
3393 {
3394 network_command = NULL;
3395 }
3396
3397
3398 void
on_network_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3399 on_network_spinbutton_value_changed (GtkSpinButton *spinbutton,
3400 gpointer user_data)
3401 {
3402 gtk_spin_button_update( spinbutton );
3403 Network_Command( EDITOR_DATA );
3404 }
3405
3406
3407 void
on_network_new_button_clicked(GtkButton * button,gpointer user_data)3408 on_network_new_button_clicked (GtkButton *button,
3409 gpointer user_data)
3410 {
3411 Network_Command( EDITOR_NEW );
3412 }
3413
3414
3415 void
on_network_cancel_button_clicked(GtkButton * button,gpointer user_data)3416 on_network_cancel_button_clicked (GtkButton *button,
3417 gpointer user_data)
3418 {
3419 Network_Command( EDITOR_CANCEL );
3420 gtk_widget_destroy( network_command );
3421 }
3422
3423
3424 void
on_network_apply_button_clicked(GtkButton * button,gpointer user_data)3425 on_network_apply_button_clicked (GtkButton *button,
3426 gpointer user_data)
3427 {
3428 Network_Command( EDITOR_APPLY );
3429 }
3430
3431
3432 void
on_network_ok_button_clicked(GtkButton * button,gpointer user_data)3433 on_network_ok_button_clicked (GtkButton *button,
3434 gpointer user_data)
3435 {
3436 Network_Command( EDITOR_APPLY );
3437 gtk_widget_destroy( network_command );
3438 }
3439
3440
3441 void
on_txline_command_destroy(GtkObject * object,gpointer user_data)3442 on_txline_command_destroy (GtkObject *object,
3443 gpointer user_data)
3444 {
3445 txline_command = NULL;
3446 }
3447
3448
3449 void
on_txline_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3450 on_txline_spinbutton_value_changed (GtkSpinButton *spinbutton,
3451 gpointer user_data)
3452 {
3453 gtk_spin_button_update( spinbutton );
3454 Txline_Command( EDITOR_DATA );
3455 }
3456
3457
3458 void
on_txline_new_button_clicked(GtkButton * button,gpointer user_data)3459 on_txline_new_button_clicked (GtkButton *button,
3460 gpointer user_data)
3461 {
3462 Txline_Command( EDITOR_NEW );
3463 }
3464
3465
3466 void
on_txline_cancel_button_clicked(GtkButton * button,gpointer user_data)3467 on_txline_cancel_button_clicked (GtkButton *button,
3468 gpointer user_data)
3469 {
3470 Txline_Command( EDITOR_CANCEL );
3471 gtk_widget_destroy( txline_command );
3472 }
3473
3474
3475 void
on_txline_apply_button_clicked(GtkButton * button,gpointer user_data)3476 on_txline_apply_button_clicked (GtkButton *button,
3477 gpointer user_data)
3478 {
3479 Txline_Command( EDITOR_APPLY );
3480 }
3481
3482
3483 void
on_txline_ok_button_clicked(GtkButton * button,gpointer user_data)3484 on_txline_ok_button_clicked (GtkButton *button,
3485 gpointer user_data)
3486 {
3487 Txline_Command( EDITOR_APPLY );
3488 gtk_widget_destroy( txline_command );
3489 }
3490
3491
3492 void
on_txline_checkbutton_toggled(GtkToggleButton * togglebutton,gpointer user_data)3493 on_txline_checkbutton_toggled (GtkToggleButton *togglebutton,
3494 gpointer user_data)
3495 {
3496 Txline_Command( COMMAND_CKBUTTON );
3497 }
3498
3499
3500 void
on_ground2_command_destroy(GtkObject * object,gpointer user_data)3501 on_ground2_command_destroy (GtkObject *object,
3502 gpointer user_data)
3503 {
3504 ground2_command = NULL;
3505 }
3506
3507
3508 void
on_ground2_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3509 on_ground2_spinbutton_value_changed (GtkSpinButton *spinbutton,
3510 gpointer user_data)
3511 {
3512 gtk_spin_button_update( spinbutton );
3513 Ground2_Command( EDITOR_DATA );
3514 }
3515
3516
3517 void
on_ground2_new_button_clicked(GtkButton * button,gpointer user_data)3518 on_ground2_new_button_clicked (GtkButton *button,
3519 gpointer user_data)
3520 {
3521 Ground2_Command( EDITOR_NEW );
3522 }
3523
3524
3525 void
on_ground2_cancel_button_clicked(GtkButton * button,gpointer user_data)3526 on_ground2_cancel_button_clicked (GtkButton *button,
3527 gpointer user_data)
3528 {
3529 Ground2_Command( EDITOR_CANCEL );
3530 gtk_widget_destroy( ground2_command );
3531 }
3532
3533
3534 void
on_ground2_apply_button_clicked(GtkButton * button,gpointer user_data)3535 on_ground2_apply_button_clicked (GtkButton *button,
3536 gpointer user_data)
3537 {
3538 Ground2_Command( EDITOR_APPLY );
3539 }
3540
3541
3542 void
on_ground2_ok_button_clicked(GtkButton * button,gpointer user_data)3543 on_ground2_ok_button_clicked (GtkButton *button,
3544 gpointer user_data)
3545 {
3546 Ground2_Command( EDITOR_APPLY );
3547 gtk_widget_destroy( ground2_command );
3548 }
3549
3550
3551 void
on_loop_start_clicked(GtkButton * button,gpointer user_data)3552 on_loop_start_clicked (GtkButton *button,
3553 gpointer user_data)
3554 {
3555 Start_Frequency_Loop();
3556 }
3557
3558
3559 void
on_loop_pause_clicked(GtkButton * button,gpointer user_data)3560 on_loop_pause_clicked (GtkButton *button,
3561 gpointer user_data)
3562 {
3563 if( isFlagSet(FREQ_LOOP_RUNNING) )
3564 SetFlag( FREQ_LOOP_STOP );
3565 }
3566
3567
3568 void
on_loop_reset_clicked(GtkButton * button,gpointer user_data)3569 on_loop_reset_clicked (GtkButton *button,
3570 gpointer user_data)
3571 {
3572 if( isFlagClear(FREQ_LOOP_RUNNING) )
3573 {
3574 SetFlag( FREQ_LOOP_INIT );
3575 ClearFlag( FREQ_LOOP_RUNNING );
3576 }
3577 }
3578
3579 static GtkWidget *aboutdialog = NULL;
3580 void
on_about_activate(GtkMenuItem * menuitem,gpointer user_data)3581 on_about_activate (GtkMenuItem *menuitem,
3582 gpointer user_data)
3583 {
3584 if( aboutdialog == NULL )
3585 {
3586 aboutdialog = create_aboutdialog();
3587 gtk_widget_show( aboutdialog );
3588 gtk_about_dialog_set_program_name(
3589 GTK_ABOUT_DIALOG(aboutdialog), PACKAGE );
3590 gtk_about_dialog_set_version(
3591 GTK_ABOUT_DIALOG(aboutdialog), VERSION );
3592 }
3593 }
3594
3595
3596 void
on_aboutdialog_close(GtkDialog * dialog,gpointer user_data)3597 on_aboutdialog_close (GtkDialog *dialog,
3598 gpointer user_data)
3599 {
3600 gtk_widget_destroy( aboutdialog );
3601 aboutdialog = NULL;
3602 }
3603
3604
3605 void
on_aboutdialog_response(GtkDialog * dialog,gint response_id,gpointer user_data)3606 on_aboutdialog_response (GtkDialog *dialog,
3607 gint response_id,
3608 gpointer user_data)
3609 {
3610 gtk_widget_destroy( aboutdialog );
3611 aboutdialog = NULL;
3612 }
3613
3614
3615 void
on_net_gain_activate(GtkMenuItem * menuitem,gpointer user_data)3616 on_net_gain_activate (GtkMenuItem *menuitem,
3617 gpointer user_data)
3618 {
3619 if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)) )
3620 SetFlag( PLOT_NETGAIN );
3621 else
3622 ClearFlag( PLOT_NETGAIN );
3623
3624 /* Trigger a redraw of frequency plots drawingarea */
3625 if( isFlagSet(PLOT_ENABLED) && isFlagSet(FREQ_LOOP_DONE) )
3626 Plot_Frequency_Data();
3627 }
3628
3629
3630 gboolean
on_structure_drawingarea_button_press_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3631 on_structure_drawingarea_button_press_event
3632 (GtkWidget *widget,
3633 GdkEventButton *event,
3634 gpointer user_data)
3635 {
3636 structure_proj_params.reset = TRUE;
3637 return FALSE;
3638 }
3639
3640
3641 void
on_structure_zoom_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3642 on_structure_zoom_spinbutton_value_changed
3643 (GtkSpinButton *spinbutton,
3644 gpointer user_data)
3645 {
3646 structure_proj_params.xy_zoom = gtk_spin_button_get_value( spinbutton );
3647 structure_proj_params.xy_zoom /= 100.0;
3648 structure_proj_params.xy_scale =
3649 structure_proj_params.xy_scale1 * structure_proj_params.xy_zoom;
3650
3651 /* Trigger a redraw of structure drawingarea */
3652 Draw_Structure( structure_drawingarea );
3653 }
3654
3655
3656 void
on_structure_plus_button_clicked(GtkButton * button,gpointer user_data)3657 on_structure_plus_button_clicked (GtkButton *button,
3658 gpointer user_data)
3659 {
3660 structure_proj_params.xy_zoom =
3661 gtk_spin_button_get_value( structure_zoom );
3662 structure_proj_params.xy_zoom *= 1.1;
3663 gtk_spin_button_set_value(
3664 structure_zoom, structure_proj_params.xy_zoom );
3665 }
3666
3667
3668 void
on_structure_minus_button_clicked(GtkButton * button,gpointer user_data)3669 on_structure_minus_button_clicked (GtkButton *button,
3670 gpointer user_data)
3671 {
3672 structure_proj_params.xy_zoom =
3673 gtk_spin_button_get_value( structure_zoom );
3674 structure_proj_params.xy_zoom /= 1.1;
3675 gtk_spin_button_set_value(
3676 structure_zoom, structure_proj_params.xy_zoom );
3677 }
3678
3679
3680 void
on_structure_one_button_clicked(GtkButton * button,gpointer user_data)3681 on_structure_one_button_clicked (GtkButton *button,
3682 gpointer user_data)
3683 {
3684 gtk_spin_button_set_value( structure_zoom, 100.0 );
3685 structure_proj_params.reset = TRUE;
3686 New_Projection_Parameters(
3687 structure_pixmap_width,
3688 structure_pixmap_height,
3689 &structure_proj_params );
3690 Draw_Structure( structure_drawingarea );
3691 }
3692
3693
3694 gboolean
on_rdpattern_drawingarea_button_press_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3695 on_rdpattern_drawingarea_button_press_event
3696 (GtkWidget *widget,
3697 GdkEventButton *event,
3698 gpointer user_data)
3699 {
3700 rdpattern_proj_params.reset = TRUE;
3701 return FALSE;
3702 }
3703
3704
3705 void
on_rdpattern_zoom_spinbutton_value_changed(GtkSpinButton * spinbutton,gpointer user_data)3706 on_rdpattern_zoom_spinbutton_value_changed
3707 (GtkSpinButton *spinbutton,
3708 gpointer user_data)
3709 {
3710 rdpattern_proj_params.xy_zoom = gtk_spin_button_get_value( spinbutton );
3711 rdpattern_proj_params.xy_zoom /= 100.0;
3712 rdpattern_proj_params.xy_scale =
3713 rdpattern_proj_params.xy_scale1 * rdpattern_proj_params.xy_zoom;
3714
3715 /* Trigger a redraw of structure drawingarea */
3716 Draw_Radiation( rdpattern_drawingarea );
3717 }
3718
3719
3720 void
on_rdpattern_plus_button_clicked(GtkButton * button,gpointer user_data)3721 on_rdpattern_plus_button_clicked (GtkButton *button,
3722 gpointer user_data)
3723 {
3724 rdpattern_proj_params.xy_zoom =
3725 gtk_spin_button_get_value( rdpattern_zoom );
3726 rdpattern_proj_params.xy_zoom *= 1.1;
3727 gtk_spin_button_set_value(
3728 rdpattern_zoom, rdpattern_proj_params.xy_zoom );
3729 }
3730
3731
3732 void
on_rdpattern_minus_button_clicked(GtkButton * button,gpointer user_data)3733 on_rdpattern_minus_button_clicked (GtkButton *button,
3734 gpointer user_data)
3735 {
3736 rdpattern_proj_params.xy_zoom =
3737 gtk_spin_button_get_value( rdpattern_zoom );
3738 rdpattern_proj_params.xy_zoom /= 1.1;
3739 gtk_spin_button_set_value(
3740 rdpattern_zoom, rdpattern_proj_params.xy_zoom );
3741 }
3742
3743
3744 void
on_rdpattern_one_button_clicked(GtkButton * button,gpointer user_data)3745 on_rdpattern_one_button_clicked (GtkButton *button,
3746 gpointer user_data)
3747 {
3748 gtk_spin_button_set_value( rdpattern_zoom, 100.0 );
3749 rdpattern_proj_params.reset = TRUE;
3750 New_Projection_Parameters(
3751 rdpattern_pixmap_width,
3752 rdpattern_pixmap_height,
3753 &rdpattern_proj_params );
3754 Draw_Radiation( rdpattern_drawingarea );
3755 }
3756
3757
3758 gboolean
on_structure_drawingarea_scroll_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)3759 on_structure_drawingarea_scroll_event (GtkWidget *widget,
3760 GdkEvent *event,
3761 gpointer user_data)
3762 {
3763 structure_proj_params.xy_zoom =
3764 gtk_spin_button_get_value( structure_zoom );
3765 if( event->scroll.direction == GDK_SCROLL_UP )
3766 structure_proj_params.xy_zoom *= 1.1;
3767 else if( event->scroll.direction == GDK_SCROLL_DOWN )
3768 structure_proj_params.xy_zoom /= 1.1;
3769 gtk_spin_button_set_value(
3770 structure_zoom, structure_proj_params.xy_zoom );
3771 return FALSE;
3772 }
3773
3774
3775 gboolean
on_rdpattern_drawingarea_scroll_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)3776 on_rdpattern_drawingarea_scroll_event (GtkWidget *widget,
3777 GdkEvent *event,
3778 gpointer user_data)
3779 {
3780 rdpattern_proj_params.xy_zoom =
3781 gtk_spin_button_get_value( rdpattern_zoom );
3782 if( event->scroll.direction == GDK_SCROLL_UP )
3783 rdpattern_proj_params.xy_zoom *= 1.1;
3784 else if( event->scroll.direction == GDK_SCROLL_DOWN )
3785 rdpattern_proj_params.xy_zoom /= 1.1;
3786 gtk_spin_button_set_value(
3787 rdpattern_zoom, rdpattern_proj_params.xy_zoom );
3788 return FALSE;
3789 }
3790
3791