1 /* NIGHTFALL Light Curve Synthesis Program */
2 /* Copyright (C) 1998 Rainer Wichmann */
3 /* */
4 /* This program is free software; you can redistribute it */
5 /* and/or modify */
6 /* it under the terms of the GNU General Public License as */
7 /* published by */
8 /* the Free Software Foundation; either version 2 of the License, or */
9 /* (at your option) any later version. */
10 /* */
11 /* This program is distributed in the hope that it will be useful, */
12 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
13 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
14 /* GNU General Public License for more details. */
15 /* */
16 /* You should have received a copy of the GNU General Public License */
17 /* along with this program; if not, write to the Free Software */
18 /* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20 /* ANSI C forbids an empty source file, so put this outside */
21
22 #include <math.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <float.h>
27 #include "Light.h"
28
29 #ifdef _WITH_GTK
30
31 /* ------------------- text entry fields ------------------------ */
32
33 /******************************************************************
34 @package nightfall
35 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
36 @version 1.0
37 @short Callback function for name entry
38 @param (GtkWidget) *widget Discarded
39 @param (GtkWidget) *entry The entry text
40 @return (void)
41 @heading Graphical User Interface
42 *******************************************************************/
enter_name(GtkWidget * widget,GtkWidget * entry)43 void enter_name(GtkWidget *widget, GtkWidget *entry)
44 {
45 const gchar *entry_text;
46 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
47 (void) sscanf(entry_text, "%128s", Orbit.Name);
48 }
49
50 /******************************************************************
51 @package nightfall
52 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
53 @version 1.0
54 @short Callback function for period entry
55 @param (GtkWidget) *widget Discarded
56 @param (GtkWidget) *entry The entry text
57 @return (void)
58 @heading Graphical User Interface
59 *******************************************************************/
enter_abs_period(GtkWidget * widget,GtkWidget * entry)60 void enter_abs_period(GtkWidget *widget, GtkWidget *entry)
61 {
62 float f; int test; const gchar *entry_text;
63 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
64 test = sscanf(entry_text, "%f", &f);
65 if (test == 1 && f >= 0.0) {
66 Orbit.TruePeriod = f;
67 /* convert days to seconds */
68 Orbit.TruePeriod = Orbit.TruePeriod * 86400.;
69 } else {
70 Orbit.TruePeriod = 0.0;
71 }
72 return;
73 }
74
75 /******************************************************************
76 @package nightfall
77 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
78 @version 1.0
79 @short Callback function for mass entry
80 @param (GtkWidget) *widget Discarded
81 @param (GtkWidget) *entry The entry text
82 @return (void)
83 @heading Graphical User Interface
84 *******************************************************************/
enter_abs_mass(GtkWidget * widget,GtkWidget * entry)85 void enter_abs_mass(GtkWidget *widget, GtkWidget *entry)
86 {
87 float f; int test; const gchar *entry_text;
88 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
89 test = sscanf(entry_text, "%f", &f);
90 if (test == 1 && f >= 0.0) {
91 Orbit.TrueMass = f;
92 /* convert solar masses to KG */
93 Orbit.TrueMass = Orbit.TrueMass * 1.989E30;
94 } else {
95 Orbit.TrueMass = 0.0;
96 }
97 return;
98 }
99
100 /******************************************************************
101 @package nightfall
102 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
103 @version 1.0
104 @short Callback function for separation entry
105 @param (GtkWidget) *widget Discarded
106 @param (GtkWidget) *entry The entry text
107 @return (void)
108 @heading Graphical User Interface
109 *******************************************************************/
enter_abs_distance(GtkWidget * widget,GtkWidget * entry)110 void enter_abs_distance(GtkWidget *widget, GtkWidget *entry)
111 {
112 float f; int test; const gchar *entry_text;
113 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
114 test = sscanf(entry_text, "%f", &f);
115 if (test == 1 && f >= 0.0) {
116 Orbit.TrueDistance = f;
117 /* convert solar radius to meter */
118 Orbit.TrueDistance = Orbit.TrueDistance * SOL_RADIUS;
119 } else {
120 Orbit.TrueDistance = 0.0;
121 }
122 return;
123 }
124
125 /******************************************************************
126 @package nightfall
127 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
128 @version 1.0
129 @short Callback function for step 1 entry
130 @param (GtkWidget) *widget Discarded
131 @param (GtkWidget) *entry The entry text
132 @return (void)
133 @heading Graphical User Interface
134 *******************************************************************/
enter_step1(GtkWidget * widget,GtkWidget * entry)135 void enter_step1(GtkWidget *widget, GtkWidget *entry)
136 {
137 float f; int test; const gchar *entry_text;
138 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
139 test = sscanf(entry_text, "%f", &f);
140 if (test == 1 && f >= FLT_EPSILON) Flags.Step[0] = f;
141 }
142
143 /******************************************************************
144 @package nightfall
145 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
146 @version 1.0
147 @short Callback function for step 2 entry
148 @param (GtkWidget) *widget Discarded
149 @param (GtkWidget) *entry The entry text
150 @return (void)
151 @heading Graphical User Interface
152 *******************************************************************/
enter_step2(GtkWidget * widget,GtkWidget * entry)153 void enter_step2(GtkWidget *widget, GtkWidget *entry)
154 {
155 float f; int test; const gchar *entry_text;
156 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
157 test = sscanf(entry_text, "%f", &f);
158 if (test == 1 && f >= FLT_EPSILON) Flags.Step[1] = f;
159 }
160
161 /******************************************************************
162 @package nightfall
163 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
164 @version 1.0
165 @short Callback function for third light U entry
166 @param (GtkWidget) *widget Discarded
167 @param (GtkWidget) *entry The entry text
168 @return (void)
169 @heading Graphical User Interface
170 *******************************************************************/
enter_thirdU(GtkWidget * widget,GtkWidget * entry)171 void enter_thirdU(GtkWidget *widget, GtkWidget *entry)
172 {
173 float f; int test; const gchar *entry_text;
174 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
175 test = sscanf(entry_text, "%f", &f);
176 if (test == 1) Orbit.Third[Umag] = f;
177 }
178
179 /******************************************************************
180 @package nightfall
181 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
182 @version 1.0
183 @short Callback function for third light B entry
184 @param (GtkWidget) *widget Discarded
185 @param (GtkWidget) *entry The entry text
186 @return (void)
187 @heading Graphical User Interface
188 *******************************************************************/
enter_thirdB(GtkWidget * widget,GtkWidget * entry)189 void enter_thirdB(GtkWidget *widget, GtkWidget *entry)
190 {
191 float f; int test; const gchar *entry_text;
192 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
193 test = sscanf(entry_text, "%f", &f);
194 if (test == 1) Orbit.Third[Bmag] = f;
195 }
196
197 /******************************************************************
198 @package nightfall
199 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
200 @version 1.0
201 @short Callback function for third light V entry
202 @param (GtkWidget) *widget Discarded
203 @param (GtkWidget) *entry The entry text
204 @return (void)
205 @heading Graphical User Interface
206 *******************************************************************/
enter_thirdV(GtkWidget * widget,GtkWidget * entry)207 void enter_thirdV(GtkWidget *widget, GtkWidget *entry)
208 {
209 float f; int test; const gchar *entry_text;
210 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
211 test = sscanf(entry_text, "%f", &f);
212 if (test == 1) Orbit.Third[Vmag] = f;
213 }
214
215 /******************************************************************
216 @package nightfall
217 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
218 @version 1.0
219 @short Callback function for third light R entry
220 @param (GtkWidget) *widget Discarded
221 @param (GtkWidget) *entry The entry text
222 @return (void)
223 @heading Graphical User Interface
224 *******************************************************************/
enter_thirdR(GtkWidget * widget,GtkWidget * entry)225 void enter_thirdR(GtkWidget *widget, GtkWidget *entry)
226 {
227 float f; int test; const gchar *entry_text;
228 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
229 test = sscanf(entry_text, "%f", &f);
230 if (test == 1) Orbit.Third[Rmag] = f;
231 }
232
233 /******************************************************************
234 @package nightfall
235 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
236 @version 1.0
237 @short Callback function for third light I entry
238 @param (GtkWidget) *widget Discarded
239 @param (GtkWidget) *entry The entry text
240 @return (void)
241 @heading Graphical User Interface
242 *******************************************************************/
enter_thirdI(GtkWidget * widget,GtkWidget * entry)243 void enter_thirdI(GtkWidget *widget, GtkWidget *entry)
244 {
245 float f; int test; const gchar *entry_text;
246 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
247 test = sscanf(entry_text, "%f", &f);
248 if (test == 1) Orbit.Third[Imag] = f;
249 }
250
251 /******************************************************************
252 @package nightfall
253 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
254 @version 1.0
255 @short Callback function for third light J entry
256 @param (GtkWidget) *widget Discarded
257 @param (GtkWidget) *entry The entry text
258 @return (void)
259 @heading Graphical User Interface
260 *******************************************************************/
enter_thirdJ(GtkWidget * widget,GtkWidget * entry)261 void enter_thirdJ(GtkWidget *widget, GtkWidget *entry)
262 {
263 float f; int test; const gchar *entry_text;
264 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
265 test = sscanf(entry_text, "%f", &f);
266 if (test == 1) Orbit.Third[Jmag] = f;
267 }
268
269 /******************************************************************
270 @package nightfall
271 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
272 @version 1.0
273 @short Callback function for third light H entry
274 @param (GtkWidget) *widget Discarded
275 @param (GtkWidget) *entry The entry text
276 @return (void)
277 @heading Graphical User Interface
278 *******************************************************************/
enter_thirdH(GtkWidget * widget,GtkWidget * entry)279 void enter_thirdH(GtkWidget *widget, GtkWidget *entry)
280 {
281 float f; int test; const gchar *entry_text;
282 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
283 test = sscanf(entry_text, "%f", &f);
284 if (test == 1) Orbit.Third[Hmag] = f;
285 }
286
287 /******************************************************************
288 @package nightfall
289 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
290 @version 1.0
291 @short Callback function for third light K entry
292 @param (GtkWidget) *widget Discarded
293 @param (GtkWidget) *entry The entry text
294 @return (void)
295 @heading Graphical User Interface
296 *******************************************************************/
enter_thirdK(GtkWidget * widget,GtkWidget * entry)297 void enter_thirdK(GtkWidget *widget, GtkWidget *entry)
298 {
299 float f; int test; const gchar *entry_text;
300 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
301 test = sscanf(entry_text, "%f", &f);
302 if (test == 1) Orbit.Third[Kmag] = f;
303 }
304
305 /******************************************************************
306 @package nightfall
307 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
308 @version 1.0
309 @short Callback function for third light u entry
310 @param (GtkWidget) *widget Discarded
311 @param (GtkWidget) *entry The entry text
312 @return (void)
313 @heading Graphical User Interface
314 *******************************************************************/
enter_thirdu(GtkWidget * widget,GtkWidget * entry)315 void enter_thirdu(GtkWidget *widget, GtkWidget *entry)
316 {
317 float f; int test; const gchar *entry_text;
318 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
319 test = sscanf(entry_text, "%f", &f);
320 if (test == 1) Orbit.Third[umag] = f;
321 }
322
323 /******************************************************************
324 @package nightfall
325 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
326 @version 1.0
327 @short Callback function for third light v entry
328 @param (GtkWidget) *widget Discarded
329 @param (GtkWidget) *entry The entry text
330 @return (void)
331 @heading Graphical User Interface
332 *******************************************************************/
enter_thirdv(GtkWidget * widget,GtkWidget * entry)333 void enter_thirdv(GtkWidget *widget, GtkWidget *entry)
334 {
335 float f; int test; const gchar *entry_text;
336 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
337 test = sscanf(entry_text, "%f", &f);
338 if (test == 1) Orbit.Third[vmag] = f;
339 }
340
341 /******************************************************************
342 @package nightfall
343 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
344 @version 1.0
345 @short Callback function for third light b entry
346 @param (GtkWidget) *widget Discarded
347 @param (GtkWidget) *entry The entry text
348 @return (void)
349 @heading Graphical User Interface
350 *******************************************************************/
enter_thirdb(GtkWidget * widget,GtkWidget * entry)351 void enter_thirdb(GtkWidget *widget, GtkWidget *entry)
352 {
353 float f; int test; const gchar *entry_text;
354 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
355 test = sscanf(entry_text, "%f", &f);
356 if (test == 1) Orbit.Third[bmag] = f;
357 }
358
359 /******************************************************************
360 @package nightfall
361 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
362 @version 1.0
363 @short Callback function for third light y entry
364 @param (GtkWidget) *widget Discarded
365 @param (GtkWidget) *entry The entry text
366 @return (void)
367 @heading Graphical User Interface
368 *******************************************************************/
enter_thirdy(GtkWidget * widget,GtkWidget * entry)369 void enter_thirdy(GtkWidget *widget, GtkWidget *entry)
370 {
371 float f; int test; const gchar *entry_text;
372 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
373 test = sscanf(entry_text, "%f", &f);
374 if (test == 1) Orbit.Third[ymag] = f;
375 }
376
377 /******************************************************************
378 @package nightfall
379 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
380 @version 1.0
381 @short Callback function for longitude entry of first Primary spot
382 @param (GtkWidget) *widget Discarded
383 @param (GtkWidget) *entry The entry text
384 @return (void)
385 @heading Graphical User Interface
386 *******************************************************************/
enter_longitude_p_spot1(GtkWidget * widget,GtkWidget * entry)387 void enter_longitude_p_spot1(GtkWidget *widget, GtkWidget *entry)
388 {
389 float f; int test; const gchar *entry_text;
390 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
391 test = sscanf(entry_text, "%f", &f);
392 if (test == 1) { SpotStore[Primary][0].longitude = f;
393 if (SpotActive[0] == ON) Spot[Primary][0].longitude = f; }
394 }
395 /******************************************************************
396 @package nightfall
397 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
398 @version 1.0
399 @short Callback function for longitude entry of second Primary spot
400 @param (GtkWidget) *widget Discarded
401 @param (GtkWidget) *entry The entry text
402 @return (void)
403 @heading Graphical User Interface
404 *******************************************************************/
enter_longitude_p_spot2(GtkWidget * widget,GtkWidget * entry)405 void enter_longitude_p_spot2(GtkWidget *widget, GtkWidget *entry)
406 {
407 float f; int test; const gchar *entry_text;
408 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
409 test = sscanf(entry_text, "%f", &f);
410 if (test == 1) { SpotStore[Primary][1].longitude = f;
411 if (SpotActive[1] == ON && SpotActive[0] == ON)
412 Spot[Primary][1].longitude = f;
413 if (SpotActive[1] == ON && SpotActive[0] == OFF)
414 Spot[Primary][0].longitude = f; }
415 }
416 /******************************************************************
417 @package nightfall
418 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
419 @version 1.0
420 @short Callback function for longitude entry of first Secondary spot
421 @param (GtkWidget) *widget Discarded
422 @param (GtkWidget) *entry The entry text
423 @return (void)
424 @heading Graphical User Interface
425 *******************************************************************/
enter_longitude_s_spot1(GtkWidget * widget,GtkWidget * entry)426 void enter_longitude_s_spot1(GtkWidget *widget, GtkWidget *entry)
427 {
428 float f; int test; const gchar *entry_text;
429 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
430 test = sscanf(entry_text, "%f", &f);
431 if (test == 1) { SpotStore[Secondary][0].longitude = f;
432 if (SpotActive[2] == ON) Spot[Secondary][0].longitude = f; }
433 }
434 /******************************************************************
435 @package nightfall
436 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
437 @version 1.0
438 @short Callback function for longitude entry of second Secondary spot
439 @param (GtkWidget) *widget Discarded
440 @param (GtkWidget) *entry The entry text
441 @return (void)
442 @heading Graphical User Interface
443 *******************************************************************/
enter_longitude_s_spot2(GtkWidget * widget,GtkWidget * entry)444 void enter_longitude_s_spot2(GtkWidget *widget, GtkWidget *entry)
445 {
446 float f; int test; const gchar *entry_text;
447 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
448 test = sscanf(entry_text, "%f", &f);
449 if (test == 1) { SpotStore[Secondary][1].longitude = f;
450 if (SpotActive[3] == ON && SpotActive[2]== ON)
451 Spot[Secondary][1].longitude = f;
452 if (SpotActive[3] == ON && SpotActive[2]== OFF)
453 Spot[Secondary][0].longitude = f; }
454 }
455 /******************************************************************
456 @package nightfall
457 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
458 @version 1.0
459 @short Callback function for latitude entry of first Primary spot
460 @param (GtkWidget) *widget Discarded
461 @param (GtkWidget) *entry The entry text
462 @return (void)
463 @heading Graphical User Interface
464 *******************************************************************/
enter_latitude_p_spot1(GtkWidget * widget,GtkWidget * entry)465 void enter_latitude_p_spot1(GtkWidget *widget, GtkWidget *entry)
466 {
467 float f; int test; const gchar *entry_text;
468 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
469 test = sscanf(entry_text, "%f", &f);
470 if (test == 1) { SpotStore[Primary][0].latitude = f;
471 if (SpotActive[0] == ON) Spot[Primary][0].latitude = f; }
472 }
473 /******************************************************************
474 @package nightfall
475 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
476 @version 1.0
477 @short Callback function for latitude entry of second Primary spot
478 @param (GtkWidget) *widget Discarded
479 @param (GtkWidget) *entry The entry text
480 @return (void)
481 @heading Graphical User Interface
482 *******************************************************************/
enter_latitude_p_spot2(GtkWidget * widget,GtkWidget * entry)483 void enter_latitude_p_spot2(GtkWidget *widget, GtkWidget *entry)
484 {
485 float f; int test; const gchar *entry_text;
486 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
487 test = sscanf(entry_text, "%f", &f);
488 if (test == 1) { SpotStore[Primary][1].latitude = f;
489 if (SpotActive[1] == ON && SpotActive[0] == ON)
490 Spot[Primary][1].latitude = f;
491 if (SpotActive[1] == ON && SpotActive[0] == OFF)
492 Spot[Primary][0].latitude = f; }
493 }
494 /******************************************************************
495 @package nightfall
496 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
497 @version 1.0
498 @short Callback function for latitude entry of first Secondary spot
499 @param (GtkWidget) *widget Discarded
500 @param (GtkWidget) *entry The entry text
501 @return (void)
502 @heading Graphical User Interface
503 *******************************************************************/
enter_latitude_s_spot1(GtkWidget * widget,GtkWidget * entry)504 void enter_latitude_s_spot1(GtkWidget *widget, GtkWidget *entry)
505 {
506 float f; int test; const gchar *entry_text;
507 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
508 test = sscanf(entry_text, "%f", &f);
509 if (test == 1) { SpotStore[Secondary][0].latitude = f;
510 if (SpotActive[2] == ON) Spot[Secondary][0].latitude = f; }
511 }
512 /******************************************************************
513 @package nightfall
514 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
515 @version 1.0
516 @short Callback function for latitude entry of second Secondary spot
517 @param (GtkWidget) *widget Discarded
518 @param (GtkWidget) *entry The entry text
519 @return (void)
520 @heading Graphical User Interface
521 *******************************************************************/
enter_latitude_s_spot2(GtkWidget * widget,GtkWidget * entry)522 void enter_latitude_s_spot2(GtkWidget *widget, GtkWidget *entry)
523 {
524 float f; int test; const gchar *entry_text;
525 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
526 test = sscanf(entry_text, "%f", &f);
527 if (test == 1) { SpotStore[Secondary][1].latitude = f;
528 if (SpotActive[3] == ON && SpotActive[2]== ON)
529 Spot[Secondary][1].latitude = f;
530 if (SpotActive[3] == ON && SpotActive[2]== OFF)
531 Spot[Secondary][0].latitude = f; }
532 }
533
534 /******************************************************************
535 @package nightfall
536 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
537 @version 1.0
538 @short Callback function for radius entry of first Primary spot
539 @param (GtkWidget) *widget Discarded
540 @param (GtkWidget) *entry The entry text
541 @return (void)
542 @heading Graphical User Interface
543 *******************************************************************/
enter_radius_p_spot1(GtkWidget * widget,GtkWidget * entry)544 void enter_radius_p_spot1(GtkWidget *widget, GtkWidget *entry)
545 {
546 float f; int test; const gchar *entry_text;
547 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
548 test = sscanf(entry_text, "%f", &f);
549 if (test == 1) { SpotStore[Primary][0].radius = f;
550 if (SpotActive[0] == ON) Spot[Primary][0].radius = f; }
551 }
552 /******************************************************************
553 @package nightfall
554 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
555 @version 1.0
556 @short Callback function for radius entry of second Primary spot
557 @param (GtkWidget) *widget Discarded
558 @param (GtkWidget) *entry The entry text
559 @return (void)
560 @heading Graphical User Interface
561 *******************************************************************/
enter_radius_p_spot2(GtkWidget * widget,GtkWidget * entry)562 void enter_radius_p_spot2(GtkWidget *widget, GtkWidget *entry)
563 {
564 float f; int test; const gchar *entry_text;
565 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
566 test = sscanf(entry_text, "%f", &f);
567 if (test == 1) { SpotStore[Primary][1].radius = f;
568 if (SpotActive[1] == ON && SpotActive[0] == ON)
569 Spot[Primary][1].radius = f;
570 if (SpotActive[1] == ON && SpotActive[0] == OFF)
571 Spot[Primary][0].radius = f; }
572 }
573 /******************************************************************
574 @package nightfall
575 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
576 @version 1.0
577 @short Callback function for radius entry of first Secondary spot
578 @param (GtkWidget) *widget Discarded
579 @param (GtkWidget) *entry The entry text
580 @return (void)
581 @heading Graphical User Interface
582 *******************************************************************/
enter_radius_s_spot1(GtkWidget * widget,GtkWidget * entry)583 void enter_radius_s_spot1(GtkWidget *widget, GtkWidget *entry)
584 {
585 float f; int test; const gchar *entry_text;
586 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
587 test = sscanf(entry_text, "%f", &f);
588 if (test == 1) { SpotStore[Secondary][0].radius = f;
589 if (SpotActive[2] == ON) Spot[Secondary][0].radius = f; }
590 }
591 /******************************************************************
592 @package nightfall
593 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
594 @version 1.0
595 @short Callback function for radius entry of second Secondary spot
596 @param (GtkWidget) *widget Discarded
597 @param (GtkWidget) *entry The entry text
598 @return (void)
599 @heading Graphical User Interface
600 *******************************************************************/
enter_radius_s_spot2(GtkWidget * widget,GtkWidget * entry)601 void enter_radius_s_spot2(GtkWidget *widget, GtkWidget *entry)
602 {
603 float f; int test; const gchar *entry_text;
604 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
605 test = sscanf(entry_text, "%f", &f);
606 if (test == 1) {
607 SpotStore[Secondary][1].radius = f;
608 if (SpotActive[3] == ON && SpotActive[2]== ON)
609 Spot[Secondary][1].radius = f;
610 if (SpotActive[3] == ON && SpotActive[2]== OFF)
611 Spot[Secondary][0].radius = f;
612 }
613 }
614
615 /******************************************************************
616 @package nightfall
617 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
618 @version 1.0
619 @short Callback function for dimfactor entry of first Primary spot
620 @param (GtkWidget) *widget Discarded
621 @param (GtkWidget) *entry The entry text
622 @return (void)
623 @heading Graphical User Interface
624 *******************************************************************/
enter_dimfactor_p_spot1(GtkWidget * widget,GtkWidget * entry)625 void enter_dimfactor_p_spot1(GtkWidget *widget, GtkWidget *entry)
626 {
627 float f; int test; const gchar *entry_text;
628 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
629 test = sscanf(entry_text, "%f", &f);
630 if (test == 1) {
631 SpotStore[Primary][0].dimfactor = f;
632 if (SpotActive[0] == ON)
633 Spot[Primary][0].dimfactor = f;
634 }
635 }
636 /******************************************************************
637 @package nightfall
638 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
639 @version 1.0
640 @short Callback function for dimfactor entry of second Primary spot
641 @param (GtkWidget) *widget Discarded
642 @param (GtkWidget) *entry The entry text
643 @return (void)
644 @heading Graphical User Interface
645 *******************************************************************/
enter_dimfactor_p_spot2(GtkWidget * widget,GtkWidget * entry)646 void enter_dimfactor_p_spot2(GtkWidget *widget, GtkWidget *entry)
647 {
648 float f; int test; const gchar *entry_text;
649 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
650 test = sscanf(entry_text, "%f", &f);
651 if (test == 1) { SpotStore[Primary][1].dimfactor = f;
652 if (SpotActive[1] == ON && SpotActive[0] == ON)
653 Spot[Primary][1].dimfactor = f;
654 if (SpotActive[1] == ON && SpotActive[0] == OFF)
655 Spot[Primary][0].dimfactor = f; }
656 }
657 /******************************************************************
658 @package nightfall
659 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
660 @version 1.0
661 @short Callback function for dimfactor entry of first Secondary spot
662 @param (GtkWidget) *widget Discarded
663 @param (GtkWidget) *entry The entry text
664 @return (void)
665 @heading Graphical User Interface
666 *******************************************************************/
enter_dimfactor_s_spot1(GtkWidget * widget,GtkWidget * entry)667 void enter_dimfactor_s_spot1(GtkWidget *widget, GtkWidget *entry)
668 {
669 float f; int test; const gchar *entry_text;
670 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
671 test = sscanf(entry_text, "%f", &f);
672 if (test == 1) { SpotStore[Secondary][0].dimfactor = f;
673 if (SpotActive[2] == ON) Spot[Secondary][0].dimfactor = f; }
674 }
675 /******************************************************************
676 @package nightfall
677 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
678 @version 1.0
679 @short Callback function for dimfactor entry of second Secondary spot
680 @param (GtkWidget) *widget Discarded
681 @param (GtkWidget) *entry The entry text
682 @return (void)
683 @heading Graphical User Interface
684 *******************************************************************/
enter_dimfactor_s_spot2(GtkWidget * widget,GtkWidget * entry)685 void enter_dimfactor_s_spot2(GtkWidget *widget, GtkWidget *entry)
686 {
687 float f; int test; const gchar *entry_text;
688 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
689 test = sscanf(entry_text, "%f", &f);
690 if (test == 1) { SpotStore[Secondary][1].dimfactor = f;
691 if (SpotActive[3] == ON && SpotActive[2]== ON)
692 Spot[Secondary][1].dimfactor = f;
693 if (SpotActive[3] == ON && SpotActive[2]== OFF)
694 Spot[Secondary][0].dimfactor = f; }
695 }
696
697 /******************************************************************
698 @package nightfall
699 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
700 @version 1.0
701 @short Callback function for mass ratio entry
702 @param (GtkWidget) *widget Discarded
703 @param (GtkWidget) *entry The entry text
704 @return (void)
705 @heading Graphical User Interface
706 *******************************************************************/
enter_massratio(GtkWidget * widget,GtkWidget * entry)707 void enter_massratio(GtkWidget *widget, GtkWidget *entry)
708 {
709 float f;
710 int test;
711 const gchar *entry_text;
712
713 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
714 test = sscanf(entry_text, "%f", &f);
715 if (test == 1 && f > FLT_EPSILON)
716 {
717 Binary[Primary].Mq = f;
718 Binary[Secondary].Mq = 1.0/f;
719 }
720 }
721
722 /******************************************************************
723 @package nightfall
724 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
725 @version 1.0
726 @short Callback function for inclination entry
727 @param (GtkWidget) *widget Discarded
728 @param (GtkWidget) *entry The entry text
729 @return (void)
730 @heading Graphical User Interface
731 *******************************************************************/
enter_inclination(GtkWidget * widget,GtkWidget * entry)732 void enter_inclination(GtkWidget *widget, GtkWidget *entry)
733 {
734 float f;
735 int test;
736 const gchar *entry_text;
737
738 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
739 test = sscanf(entry_text, "%f", &f);
740 if (test == 1) Orbit.Inclination = DTOR * f;
741 #ifdef _WITH_OPENGL
742 if ( GLWindowOpened == ON ) {
743 GLUpdate3d(glArea);
744 GLDisplay3d(glArea);
745 }
746 #endif
747 }
748
749 /******************************************************************
750 @package nightfall
751 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
752 @version 1.0
753 @short Callback function for Primary Roche fill factor entry
754 @param (GtkWidget) *widget Discarded
755 @param (GtkWidget) *entry The entry text
756 @return (void)
757 @heading Graphical User Interface
758 *******************************************************************/
enter_rochefill1(GtkWidget * widget,GtkWidget * entry)759 void enter_rochefill1(GtkWidget *widget, GtkWidget *entry)
760 {
761 float f;
762 int test;
763 const gchar *entry_text;
764
765 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
766 test = sscanf(entry_text, "%f", &f);
767 if (test == 1)
768 {
769 if (Flags.edu != ON)
770 {
771 Binary[Primary].RocheFill = f;
772 }
773 else
774 {
775 Binary[Primary].Radius = (f * SOL_RADIUS) / Orbit.TrueDistance;
776 Binary[Primary].RocheFill = Binary[Primary].Radius / Binary[Primary].RCrit;
777 if ((Binary[Primary].RocheFill >= LIM_RF_L) && (Binary[Primary].RocheFill <= LIM_RF_H)) {
778 DefineParam(Primary);
779 }
780 }
781 }
782 }
783
784 /******************************************************************
785 @package nightfall
786 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
787 @version 1.0
788 @short Callback function for Secondary Roche fill factor entry
789 @param (GtkWidget) *widget Discarded
790 @param (GtkWidget) *entry The entry text
791 @return (void)
792 @heading Graphical User Interface
793 *******************************************************************/
enter_rochefill2(GtkWidget * widget,GtkWidget * entry)794 void enter_rochefill2(GtkWidget *widget, GtkWidget *entry)
795 {
796 float f;
797 int test;
798 const gchar *entry_text;
799
800 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
801 test = sscanf(entry_text, "%f", &f);
802 if (test == 1)
803 {
804 if (Flags.edu != ON)
805 {
806 Binary[Secondary].RocheFill = f;
807 }
808 else
809 {
810 Binary[Secondary].Radius = (f * SOL_RADIUS) / Orbit.TrueDistance;
811 Binary[Secondary].RocheFill = Binary[Secondary].Radius / Binary[Secondary].RCrit;
812 if ((Binary[Secondary].RocheFill >= LIM_RF_L) && (Binary[Secondary].RocheFill <= LIM_RF_H)) {
813 DefineParam(Secondary);
814 }
815 }
816 }
817 }
818
819 /******************************************************************
820 @package nightfall
821 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
822 @version 1.0
823 @short Callback function for Primary temperature entry
824 @param (GtkWidget) *widget Discarded
825 @param (GtkWidget) *entry The entry text
826 @return (void)
827 @heading Graphical User Interface
828 *******************************************************************/
enter_temp1(GtkWidget * widget,GtkWidget * entry)829 void enter_temp1(GtkWidget *widget, GtkWidget *entry)
830 {
831 float f;
832 int test;
833 const gchar *entry_text;
834
835 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
836 test = sscanf(entry_text, "%f", &f);
837 if (test == 1) Binary[Primary].Temperature = f;
838 }
839
840 /******************************************************************
841 @package nightfall
842 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
843 @version 1.0
844 @short Callback function for Secondary temperature entry
845 @param (GtkWidget) *widget Discarded
846 @param (GtkWidget) *entry The entry text
847 @return (void)
848 @heading Graphical User Interface
849 *******************************************************************/
enter_temp2(GtkWidget * widget,GtkWidget * entry)850 void enter_temp2(GtkWidget *widget, GtkWidget *entry)
851 {
852 float f;
853 int test;
854 const gchar *entry_text;
855
856 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
857 test = sscanf(entry_text, "%f", &f);
858 if (test == 1) Binary[Secondary].Temperature = f;
859 }
860
861 #ifdef HAVE_DISK
862 /******************************************************************
863 @package nightfall
864 @author Markus Kuster (kuster@astro.uni-tuebingen.de)
865 @version 1.0
866 @short Callback function for outer disk radius entry
867 @param (GtkWidget) *widget Discarded
868 @param (GtkWidget) *entry The entry text
869 @return (void)
870 @heading Graphical User Interface
871 *******************************************************************/
enter_odiskrad(GtkWidget * widget,GtkWidget * entry)872 void enter_odiskrad(GtkWidget *widget, GtkWidget *entry)
873 {
874 float f;
875 int test;
876 const gchar *entry_text;
877
878 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
879 test = sscanf(entry_text, "%f", &f);
880 if (test == 1) Binary[Disk].Rout = f;
881 }
882
883 /******************************************************************
884 @package nightfall
885 @author Markus Kuster (kuster@astro.uni-tuebingen.de)
886 @version 1.0
887 @short Callback function for inner disk radius entry
888 @param (GtkWidget) *widget Discarded
889 @param (GtkWidget) *entry The entry text
890 @return (void)
891 @heading Graphical User Interface
892 *******************************************************************/
enter_idiskrad(GtkWidget * widget,GtkWidget * entry)893 void enter_idiskrad(GtkWidget *widget, GtkWidget *entry)
894 {
895 float f;
896 int test;
897 const gchar *entry_text;
898
899 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
900 test = sscanf(entry_text, "%f", &f);
901 if (test == 1) Binary[Disk].Rin = f;
902 }
903
904 /******************************************************************
905 @package nightfall
906 @author Markus Kuster (kuster@astro.uni-tuebingen.de)
907 @version 1.0
908 @short Callback function for disk tilt entry
909 @param (GtkWidget) *widget Discarded
910 @param (GtkWidget) *entry The entry text
911 @return (void)
912 @heading Graphical User Interface
913 *******************************************************************/
enter_disktilt(GtkWidget * widget,GtkWidget * entry)914 void enter_disktilt(GtkWidget *widget, GtkWidget *entry)
915 {
916 float f;
917 int test;
918 const gchar *entry_text;
919
920 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
921 test = sscanf(entry_text, "%f", &f);
922 if (test == 1) Binary[Disk].Tilt = f;
923 }
924
925 /******************************************************************
926 @package nightfall
927 @author Markus Kuster (kuster@astro.uni-tuebingen.de)
928 @version 1.0
929 @short Callback function for disk warp entry
930 @param (GtkWidget) *widget Discarded
931 @param (GtkWidget) *entry The entry text
932 @return (void)
933 @heading Graphical User Interface
934 *******************************************************************/
enter_diskwarp(GtkWidget * widget,GtkWidget * entry)935 void enter_diskwarp(GtkWidget *widget, GtkWidget *entry)
936 {
937 float f;
938 int test;
939 const gchar *entry_text;
940
941 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
942 test = sscanf(entry_text, "%f", &f);
943 if (test == 1) Binary[Disk].Warp = f;
944 }
945
946 /******************************************************************
947 @package nightfall
948 @author Markus Kuster (kuster@astro.uni-tuebingen.de)
949 @version 1.0
950 @short Callback function for disk thickness entry
951 @param (GtkWidget) *widget Discarded
952 @param (GtkWidget) *entry The entry text
953 @return (void)
954 @heading Graphical User Interface
955 *******************************************************************/
enter_diskthick(GtkWidget * widget,GtkWidget * entry)956 void enter_diskthick(GtkWidget *widget, GtkWidget *entry)
957 {
958 float f;
959 int test;
960 const gchar *entry_text;
961
962 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
963 test = sscanf(entry_text, "%f", &f);
964 if (test == 1) Binary[Disk].Thick = f;
965 }
966
967 /******************************************************************
968 @package nightfall
969 @author Markus Kuster (kuster@astro.uni-tuebingen.de)
970 @version 1.0
971 @short Callback function for disk H/R entry
972 @param (GtkWidget) *widget Discarded
973 @param (GtkWidget) *entry The entry text
974 @return (void)
975 @heading Graphical User Interface
976 *******************************************************************/
enter_diskhr(GtkWidget * widget,GtkWidget * entry)977 void enter_diskhr(GtkWidget *widget, GtkWidget *entry)
978 {
979 float f;
980 int test;
981 const gchar *entry_text;
982
983 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
984 test = sscanf(entry_text, "%f", &f);
985 if (test == 1) Binary[Disk].HR = f;
986 }
987
988 /******************************************************************
989 @package nightfall
990 @author Markus Kuster (kuster@astro.uni-tuebingen.de)
991 @version 1.0
992 @short Callback function for disk temperature entry
993 @param (GtkWidget) *widget Discarded
994 @param (GtkWidget) *entry The entry text
995 @return (void)
996 @heading Graphical User Interface
997 *******************************************************************/
enter_disktemp(GtkWidget * widget,GtkWidget * entry)998 void enter_disktemp(GtkWidget *widget, GtkWidget *entry)
999 {
1000 float f;
1001 int test;
1002 const gchar *entry_text;
1003
1004 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1005 test = sscanf(entry_text, "%f", &f);
1006 if (test == 1) Binary[Disk].Temperature = f;
1007 }
1008
1009 /******************************************************************
1010 @package nightfall
1011 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1012 @version 1.0
1013 @short Callback function for disk hot spot temperature
1014 @param (GtkWidget) *widget Discarded
1015 @param (GtkWidget) *entry The entry text
1016 @return (void)
1017 @heading Graphical User Interface
1018 *******************************************************************/
enter_hs_temp(GtkWidget * widget,GtkWidget * entry)1019 void enter_hs_temp(GtkWidget *widget, GtkWidget *entry)
1020 {
1021 float f;
1022 int test;
1023 const gchar *entry_text;
1024
1025 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1026 test = sscanf(entry_text, "%f", &f);
1027 if (test == 1) Binary[Disk].tempHS = f;
1028 }
1029
1030 /******************************************************************
1031 @package nightfall
1032 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1033 @version 1.0
1034 @short Callback function for disk hot spot longitude
1035 @param (GtkWidget) *widget Discarded
1036 @param (GtkWidget) *entry The entry text
1037 @return (void)
1038 @heading Graphical User Interface
1039 *******************************************************************/
enter_hs_longitude(GtkWidget * widget,GtkWidget * entry)1040 void enter_hs_longitude(GtkWidget *widget, GtkWidget *entry)
1041 {
1042 float f;
1043 int test;
1044 const gchar *entry_text;
1045
1046 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1047 test = sscanf(entry_text, "%f", &f);
1048 if (test == 1) Binary[Disk].longitudeHS = f;
1049 }
1050
1051 /******************************************************************
1052 @package nightfall
1053 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1054 @version 1.0
1055 @short Callback function for disk hot spot extent
1056 @param (GtkWidget) *widget Discarded
1057 @param (GtkWidget) *entry The entry text
1058 @return (void)
1059 @heading Graphical User Interface
1060 *******************************************************************/
enter_hs_extent(GtkWidget * widget,GtkWidget * entry)1061 void enter_hs_extent(GtkWidget *widget, GtkWidget *entry)
1062 {
1063 float f;
1064 int test;
1065 const gchar *entry_text;
1066
1067 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1068 test = sscanf(entry_text, "%f", &f);
1069 if (test == 1) Binary[Disk].extentHS = f;
1070 }
1071
1072 /******************************************************************
1073 @package nightfall
1074 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1075 @version 1.0
1076 @short Callback function for disk hot spot depth
1077 @param (GtkWidget) *widget Discarded
1078 @param (GtkWidget) *entry The entry text
1079 @return (void)
1080 @heading Graphical User Interface
1081 *******************************************************************/
enter_hs_depth(GtkWidget * widget,GtkWidget * entry)1082 void enter_hs_depth(GtkWidget *widget, GtkWidget *entry)
1083 {
1084 float f;
1085 int test;
1086 const gchar *entry_text;
1087
1088 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1089 test = sscanf(entry_text, "%f", &f);
1090 if (test == 1) Binary[Disk].depthHS = f;
1091 }
1092
1093 /******************************************************************
1094 @package nightfall
1095 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1096 @version 1.0
1097 @short Callback function for disk hot spot puff
1098 @param (GtkWidget) *widget Discarded
1099 @param (GtkWidget) *entry The entry text
1100 @return (void)
1101 @heading Graphical User Interface
1102 *******************************************************************/
enter_hs_puff(GtkWidget * widget,GtkWidget * entry)1103 void enter_hs_puff(GtkWidget *widget, GtkWidget *entry)
1104 {
1105 float f;
1106 int test;
1107 const gchar *entry_text;
1108
1109 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1110 test = sscanf(entry_text, "%f", &f);
1111 if (test == 1) Binary[Disk].puffHS = f;
1112 }
1113
1114 /******************************************************************
1115 @package nightfall
1116 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1117 @version 1.0
1118 @short Callback function for disk warp maximum inclination
1119 @param (GtkWidget) *widget Discarded
1120 @param (GtkWidget) *entry The entry text
1121 @return (void)
1122 @heading Graphical User Interface
1123 *******************************************************************/
enter_warp_max(GtkWidget * widget,GtkWidget * entry)1124 void enter_warp_max(GtkWidget *widget, GtkWidget *entry)
1125 {
1126 float f;
1127 int test;
1128 const gchar *entry_text;
1129
1130 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1131 test = sscanf(entry_text, "%f", &f);
1132 if (test == 1) Binary[Disk].maxWarp = f;
1133 }
1134
1135 /******************************************************************
1136 @package nightfall
1137 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1138 @version 1.0
1139 @short Callback function for disk warp longitude
1140 @param (GtkWidget) *widget Discarded
1141 @param (GtkWidget) *entry The entry text
1142 @return (void)
1143 @heading Graphical User Interface
1144 *******************************************************************/
enter_warp_longitude(GtkWidget * widget,GtkWidget * entry)1145 void enter_warp_longitude(GtkWidget *widget, GtkWidget *entry)
1146 {
1147 float f;
1148 int test;
1149 const gchar *entry_text;
1150
1151 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1152 test = sscanf(entry_text, "%f", &f);
1153 if (test == 1) Binary[Disk].longitudeWarp = f;
1154 }
1155
1156 /******************************************************************
1157 @package nightfall
1158 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1159 @version 1.0
1160 @short Callback function for disk warp width
1161 @param (GtkWidget) *widget Discarded
1162 @param (GtkWidget) *entry The entry text
1163 @return (void)
1164 @heading Graphical User Interface
1165 *******************************************************************/
enter_warp_width(GtkWidget * widget,GtkWidget * entry)1166 void enter_warp_width(GtkWidget *widget, GtkWidget *entry)
1167 {
1168 float f;
1169 int test;
1170 const gchar *entry_text;
1171
1172 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1173 test = sscanf(entry_text, "%f", &f);
1174 if (test == 1) Binary[Disk].widthWarp = f;
1175 }
1176
1177 /******************************************************************
1178 @package nightfall
1179 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1180 @version 1.0
1181 @short Callback function for disk warp centre
1182 @param (GtkWidget) *widget Discarded
1183 @param (GtkWidget) *entry The entry text
1184 @return (void)
1185 @heading Graphical User Interface
1186 *******************************************************************/
enter_warp_centre(GtkWidget * widget,GtkWidget * entry)1187 void enter_warp_centre(GtkWidget *widget, GtkWidget *entry)
1188 {
1189 float f;
1190 int test;
1191 const gchar *entry_text;
1192
1193 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1194 test = sscanf(entry_text, "%f", &f);
1195 if (test == 1) Binary[Disk].centreWarp = f;
1196 }
1197
1198 #endif
1199
1200 /******************************************************************
1201 @package nightfall
1202 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1203 @version 1.0
1204 @short Callback function for eccentricity entry
1205 @param (GtkWidget) *widget Discarded
1206 @param (GtkWidget) *entry The entry text
1207 @return (void)
1208 @heading Graphical User Interface
1209 *******************************************************************/
enter_excentricity(GtkWidget * widget,GtkWidget * entry)1210 void enter_excentricity(GtkWidget *widget, GtkWidget *entry)
1211 {
1212 float f;
1213 int test;
1214 const gchar *entry_text;
1215
1216 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1217 test = sscanf(entry_text, "%f", &f);
1218 if (test == 1) Orbit.Excentricity = f;
1219 }
1220
1221 /******************************************************************
1222 @package nightfall
1223 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1224 @version 1.0
1225 @short Callback function for periastron length entry
1226 @param (GtkWidget) *widget Discarded
1227 @param (GtkWidget) *entry The entry text
1228 @return (void)
1229 @heading Graphical User Interface
1230 *******************************************************************/
enter_omega(GtkWidget * widget,GtkWidget * entry)1231 void enter_omega(GtkWidget *widget, GtkWidget *entry)
1232 {
1233 float f;
1234 int test;
1235 const gchar *entry_text;
1236
1237 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1238 test = sscanf(entry_text, "%f", &f);
1239 if (test == 1) Orbit.Omega = f;
1240 }
1241
1242 /******************************************************************
1243 @package nightfall
1244 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1245 @version 1.0
1246 @short Callback function for asynchroneous rotation ratio Primary entry
1247 @param (GtkWidget) *widget Discarded
1248 @param (GtkWidget) *entry The entry text
1249 @return (void)
1250 @heading Graphical User Interface
1251 *******************************************************************/
enter_fratio1(GtkWidget * widget,GtkWidget * entry)1252 void enter_fratio1(GtkWidget *widget, GtkWidget *entry)
1253 {
1254 float f;
1255 int test;
1256 const gchar *entry_text;
1257
1258 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1259 test = sscanf(entry_text, "%f", &f);
1260 if (test == 1) Binary[Primary].Fratio = f;
1261 }
1262
1263 /******************************************************************
1264 @package nightfall
1265 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1266 @version 1.0
1267 @short Callback function for asynchroneous rotation ratio Secondary entry
1268 @param (GtkWidget) *widget Discarded
1269 @param (GtkWidget) *entry The entry text
1270 @return (void)
1271 @heading Graphical User Interface
1272 *******************************************************************/
enter_fratio2(GtkWidget * widget,GtkWidget * entry)1273 void enter_fratio2(GtkWidget *widget, GtkWidget *entry)
1274 {
1275 float f;
1276 int test;
1277 const gchar *entry_text;
1278
1279 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1280 test = sscanf(entry_text, "%f", &f);
1281 if (test == 1) Binary[Secondary].Fratio = f;
1282 }
1283
1284 /******************************************************************
1285 @package nightfall
1286 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1287 @version 1.0
1288 @short Callback function for log_g Primary
1289 @param (GtkWidget) *widget Discarded
1290 @param (GtkWidget) *entry The entry text
1291 @return (void)
1292 @heading Graphical User Interface
1293 *******************************************************************/
enter_log_g_1(GtkWidget * widget,GtkWidget * entry)1294 void enter_log_g_1(GtkWidget *widget, GtkWidget *entry)
1295 {
1296 float f;
1297 int test;
1298 const gchar *entry_text;
1299
1300 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1301 test = sscanf(entry_text, "%f", &f);
1302 if (test == 1) {
1303 f = 0.5 * ROUND(2.0 * f);
1304 Binary[Primary].log_g = f;
1305 }
1306 }
1307
1308 /******************************************************************
1309 @package nightfall
1310 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1311 @version 1.0
1312 @short Callback function for log_g Secondary
1313 @param (GtkWidget) *widget Discarded
1314 @param (GtkWidget) *entry The entry text
1315 @return (void)
1316 @heading Graphical User Interface
1317 *******************************************************************/
enter_log_g_2(GtkWidget * widget,GtkWidget * entry)1318 void enter_log_g_2(GtkWidget *widget, GtkWidget *entry)
1319 {
1320 float f;
1321 int test;
1322 const gchar *entry_text;
1323
1324 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1325 test = sscanf(entry_text, "%f", &f);
1326 if (test == 1) {
1327 f = 0.5 * ROUND(2.0 * f);
1328 Binary[Secondary].log_g = f;
1329 }
1330 }
1331
1332 /******************************************************************
1333 @package nightfall
1334 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1335 @version 1.0
1336 @short Callback function for line profile rest wavelength entry
1337 @param (GtkWidget) *widget Discarded
1338 @param (GtkWidget) *entry The entry text
1339 @return (void)
1340 @heading Graphical User Interface
1341 *******************************************************************/
enter_linewave(GtkWidget * widget,GtkWidget * entry)1342 void enter_linewave (GtkWidget *widget, GtkWidget *entry)
1343 {
1344 float f;
1345 int test;
1346 const gchar *entry_text;
1347
1348 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1349 test = sscanf(entry_text, "%f", &f);
1350 if (test == 1) Orbit.LambdaZero = f;
1351 }
1352
1353 /******************************************************************
1354 @package nightfall
1355 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1356 @version 1.0
1357 @short Callback function for reflection iterations entry
1358 @param (GtkWidget) *widget Discarded
1359 @param (GtkWidget) *entry The entry text
1360 @return (void)
1361 @heading Graphical User Interface
1362 *******************************************************************/
enter_reflect_iterations(GtkWidget * widget,GtkWidget * entry)1363 void enter_reflect_iterations (GtkWidget *widget, GtkWidget *entry)
1364 {
1365 int i;
1366 int test;
1367 const gchar *entry_text;
1368
1369 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1370 test = sscanf(entry_text, "%d", &i);
1371 if (test == 1) {
1372 TG_reflectstore = i;
1373 if (Flags.reflect > 0 && i > 0) Flags.reflect = i;
1374 }
1375 }
1376
1377 /******************************************************************
1378 @package nightfall
1379 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1380 @version 1.0
1381 @short Callback function for 'number of steps' entry
1382 @param (GtkWidget) *widget Discarded
1383 @param (GtkWidget) *entry The entry text
1384 @return (void)
1385 @heading Graphical User Interface
1386 *******************************************************************/
enter_phasesteps(GtkWidget * widget,GtkWidget * entry)1387 void enter_phasesteps (GtkWidget *widget, GtkWidget *entry)
1388 {
1389 int i;
1390 int test;
1391 const gchar *entry_text;
1392
1393 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1394 test = sscanf(entry_text, "%d", &i);
1395 if (test == 1) PhaseSteps = i;
1396 }
1397
1398 /******************************************************************
1399 @package nightfall
1400 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1401 @version 1.0
1402 @short Callback function for fit tolerance entry
1403 @param (GtkWidget) *widget Discarded
1404 @param (GtkWidget) *entry The entry text
1405 @return (void)
1406 @heading Graphical User Interface
1407 *******************************************************************/
enter_simplextol(GtkWidget * widget,GtkWidget * entry)1408 void enter_simplextol (GtkWidget *widget, GtkWidget *entry)
1409 {
1410 float i;
1411 int test;
1412 const gchar *entry_text;
1413
1414 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1415 test = sscanf(entry_text, "%f", &i);
1416 if (test == 1) {
1417 Flags.SimplexTol = i;
1418
1419 }
1420 }
1421
1422
1423
1424 /* --------------------- radio buttons ------------------------- */
1425
1426
1427
1428
1429 /******************************************************************
1430 @package nightfall
1431 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1432 @version 1.0
1433 @short Callback function for disk temperature distribution
1434 @param (GtkWidget) *widget Discarded
1435 @param (GtkWidget) *entry The entry text
1436 @return (void)
1437 @heading Graphical User Interface
1438 *******************************************************************/
radio_tdisk(GtkWidget * widget,gpointer * data)1439 void radio_tdisk (GtkWidget *widget, gpointer *data)
1440 {
1441
1442 int i;
1443
1444 sscanf ((char *) data, "%d", &i);
1445 if(GTK_TOGGLE_BUTTON (widget)->active) {
1446 /* button is down */
1447 Flags.tdisk = i;
1448 }
1449 }
1450
1451
1452 /******************************************************************
1453 @package nightfall
1454 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1455 @version 1.0
1456 @short Callback function for limb darkening radio buttons
1457 @param (GtkWidget) *widget Discarded
1458 @param (GtkWidget) *entry The entry text
1459 @return (void)
1460 @heading Graphical User Interface
1461 *******************************************************************/
radio_limb(GtkWidget * widget,gpointer * data)1462 void radio_limb (GtkWidget *widget, gpointer *data)
1463 {
1464
1465 int i;
1466
1467 sscanf ((char *) data, "%d", &i);
1468 if(GTK_TOGGLE_BUTTON (widget)->active) {
1469 /* button is down */
1470 Flags.limb = i;
1471 }
1472 }
1473
1474 /******************************************************************
1475 @package nightfall
1476 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1477 @version 1.0
1478 @short Callback function for passband selection radio buttons
1479 @param (GtkWidget) *widget Discarded
1480 @param (GtkWidget) *entry The entry text
1481 @return (void)
1482 @heading Graphical User Interface
1483 *******************************************************************/
radio_band(GtkWidget * widget,gpointer * data)1484 void radio_band (GtkWidget *widget, gpointer *data)
1485 {
1486 char i;
1487
1488 sscanf ((char *) data, "%c", &i);
1489 if(GTK_TOGGLE_BUTTON (widget)->active) {
1490 /* button is down */
1491 switch (i) {
1492 case '1':
1493 Flags.PlotBand = mag1;
1494 break;
1495 case 'U':
1496 Flags.PlotBand = Umag;
1497 break;
1498 case 'B':
1499 Flags.PlotBand = Bmag;
1500 break;
1501 case 'V':
1502 Flags.PlotBand = Vmag;
1503 break;
1504 case 'R':
1505 Flags.PlotBand = Rmag;
1506 break;
1507 case 'I':
1508 Flags.PlotBand = Imag;
1509 break;
1510 case 'u':
1511 Flags.PlotBand = umag;
1512 break;
1513 case 'v':
1514 Flags.PlotBand = vmag;
1515 break;
1516 case 'b':
1517 Flags.PlotBand = bmag;
1518 break;
1519 case 'y':
1520 Flags.PlotBand = ymag;
1521 break;
1522 case 'J':
1523 Flags.PlotBand = Jmag;
1524 break;
1525 case 'H':
1526 Flags.PlotBand = Hmag;
1527 break;
1528 case 'K':
1529 Flags.PlotBand = Kmag;
1530 break;
1531 default:
1532 break;
1533 }
1534 }
1535 }
1536
1537 /******************************************************************
1538 @package nightfall
1539 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1540 @version 1.0
1541 @short Callback function for plot region radio buttons
1542 @param (GtkWidget) *widget Discarded
1543 @param (GtkWidget) *entry The entry text
1544 @return (void)
1545 @heading Graphical User Interface
1546 *******************************************************************/
radio_graph(GtkWidget * widget,gpointer * data)1547 void radio_graph (GtkWidget *widget, gpointer *data)
1548 {
1549 char i;
1550
1551 sscanf ((char *) data, "%c", &i);
1552 if(GTK_TOGGLE_BUTTON (widget)->active) {
1553 /* button is down */
1554 if (i == 'P') { Flags.plot = 3; }
1555 else if (i == '2') { Flags.plot = 2; }
1556 else if (i == 'S') { Flags.plot = 4; }
1557 else if (i == '1') { Flags.plot = ON; }
1558
1559 TG_graphstore = Flags.plot;
1560 Flags.plot = OFF;
1561 }
1562 }
1563
1564 /******************************************************************
1565 @package nightfall
1566 @author Rainer Wichmann (rwichman@lsw.uni-heidelberg.de)
1567 @version 1.0
1568 @short Callback function for ViewGeometry type radio buttons
1569 @param (GtkWidget) *widget Discarded
1570 @param (GtkWidget) *entry The entry text
1571 @return (void)
1572 @heading Graphical User Interface
1573 *******************************************************************/
radio_visual(GtkWidget * widget,gpointer * data)1574 void radio_visual (GtkWidget *widget, gpointer *data)
1575 {
1576 char i;
1577
1578 sscanf ((char *) data, "%c", &i);
1579 if(GTK_TOGGLE_BUTTON (widget)->active) {
1580 /* button is down */
1581 switch (i) {
1582 case 'v':
1583 Flags.visualize = ON;
1584 break;
1585 case 'i':
1586 Flags.visualize = 2;
1587 break;
1588 case 'c':
1589 Flags.visualize = 3;
1590 break;
1591 case 'a':
1592 Flags.visualize = 4;
1593 break;
1594 default:
1595 Flags.visualize = ON;
1596 break;
1597 }
1598
1599 TG_visualstore = Flags.visualize;
1600 Flags.visualize = OFF;
1601 }
1602 }
1603
1604 #endif
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618