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