home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: Science / Science.zip / fblnk224.zip / settings.c < prev    next >
C/C++ Source or Header  |  1999-01-28  |  25KB  |  993 lines
  1. /*  settings.c  */
  2. /*  part of the fitsblink program  */
  3. /*  routines for loading and saving of some settings  */
  4. /*  Jure Skvarc, May 1998                   */
  5. #define __USE_SVID 1
  6. #include <stdio.h>
  7. #include <math.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <forms.h>
  11.  
  12. #include "functs.h"
  13.  
  14. extern STATE state;
  15. extern BLINK_FRAME *frame;
  16. extern CATALOG catalog[NUMBER_OF_CATALOGS];
  17. extern OBSERVATORY observatory;
  18. extern TELESCOPE telescope;
  19. extern MAIL mail;
  20. extern BLINK_FRAME defvals;
  21.  
  22. /*  Save some default values used by Fitsblink  */
  23. int
  24. save_settings(void)
  25.  
  26. {
  27.   char *home;
  28.   char *rcpath;
  29.   char *rcname = "/.fitsblinkrc";
  30.   FILE *fp;
  31.  
  32.   /*  Get home directory  */
  33.   home = getenv("HOME");
  34.   /*  Reserve space for full name  */
  35.   rcpath = (char *) myalloc(sizeof(char) * (strlen(home) + strlen(rcname) + 1),
  36.                 "save_settings", "rcpath");
  37.   strcpy(rcpath, home);
  38.   strcat(rcpath, rcname);
  39.   if ((fp = fopen(rcpath, "w")) == NULL) {
  40.     fl_show_alert("Can't open parameter file", "", "", 1);
  41.     return 1;
  42.   }
  43.   fprintf(fp, "USNO_PATH %s\n", catalog[CAT_USNO].path);
  44.   /*  fprintf(fp, "PPM_PATH %s\n", catalog[CAT_PPM].path); */
  45.   fprintf(fp, "GUIDE_NORTH_PATH %s\n", catalog[CAT_GUIDE].path);
  46.   fprintf(fp, "GUIDE_SOUTH_PATH %s\n", catalog[CAT_GUIDE_SOUTH].path);
  47.   fprintf(fp, "OBSERVATORY %d\n", observatory.code);
  48.   fprintf(fp, "OBSERVER %s\n", observatory.observer);
  49.   fprintf(fp, "TELESCOPE %s\n", observatory.telescope);
  50.   fprintf(fp, "INSTRUMENT %s\n", observatory.instrument);
  51.   fprintf(fp, "LONGITUDE %.6f\n", observatory.longitude);
  52.   fprintf(fp, "LATITUDE %.6f\n", observatory.latitude);
  53.   fprintf(fp, "LOGFILE %s\n", state.logfile);
  54.   fprintf(fp, "TO_ADDRESS %s\n", mail.to);
  55.   fprintf(fp, "CC_ADDRESS %s\n", mail.cc);
  56.   fprintf(fp, "MAIL_TITLE %s\n", mail.title);
  57.   fprintf(fp, "FILE_TO_MAIL %s\n", mail.file);
  58.   fprintf(fp, "DISPLAY_COLOR %d\n", (fl_get_button(state.set_display->color_setW)) ? 1 : 0);
  59.   fprintf(fp, "DISPLAY_INVERSE %d\n", (fl_get_button(state.set_display->inverse_setW)) ? 1 : 0);
  60.   fprintf(fp, "DISPLAY_DELAY %.1f\n", fl_get_counter_value(state.set_display->set_deltatW));
  61.   fprintf(fp, "DISPLAY_AUTOLEVEL_HIGH %.3f\n", state.autolevel_high);
  62.   fprintf(fp, "DISPLAY_WIDTH %d\n", state.blinkwidth);
  63.   fprintf(fp, "DISPLAY_HEIGHT %d\n", state.blinkheight);
  64.   fprintf(fp, "TEL_START %s\n", telescope.start);
  65.   fprintf(fp, "TEL_POINT %s\n", telescope.point);
  66.   fprintf(fp, "TEL_PARK %s\n", telescope.park);
  67.   fprintf(fp, "TEL_WHERE %s\n", telescope.where);
  68.   fprintf(fp, "TEL_ZERO %s\n", telescope.zero);
  69.   fprintf(fp, "TEL_CENTER %s\n", telescope.center);
  70.   fprintf(fp, "CCD_SETTEMP %s\n", telescope.settemp);
  71.   fprintf(fp, "CCD_GETTEMP %s\n", telescope.gettemp);
  72.   fprintf(fp, "CCD_EXPOSE %s\n", telescope.expose);
  73.   fprintf(fp, "COUNT_SIGMA %.2f\n", defvals.fits.sg_num);
  74.   fprintf(fp, "COUNT_MINBRIGHT %.2f\n", defvals.fits.minbright);
  75.   fprintf(fp, "COUNT_STARSIZE %d\n", defvals.fits.minstar);
  76.   fprintf(fp, "COUNT_GRIDSIZE %d\n", defvals.fits.maxsize);
  77.   fprintf(fp, "COUNT_EDGE %d\n", defvals.fits.border);
  78.   fprintf(fp, "COUNT_APERTURE %d\n", defvals.fits.aperture);
  79.   fprintf(fp, "COUNT_INNER %.2f\n", defvals.fits.inner);
  80.   fprintf(fp, "COUNT_OUTER %.2f\n", defvals.fits.outer);
  81.   fprintf(fp, "MATCH_MIN %.1f\n", defvals.match.min);
  82.   fprintf(fp, "MATCH_FIRSTBRIGHT %d\n", defvals.match.firstbright);
  83.   fprintf(fp, "MATCH_NSTAR %d\n", defvals.match.nstar);
  84.   fprintf(fp, "MATCH_POSERRMAX %.1f\n", defvals.match.poserrmax);
  85.   fprintf(fp, "MATCH_MAXRES %.1f\n", defvals.match.maxres);
  86.   fprintf(fp, "MAP_MINMAG %.1f\n", defvals.map.minmag);
  87.   fprintf(fp, "MAP_MAXMAG %.1f\n", defvals.map.maxmag);
  88.   if (state.wwwbrowser) fprintf(fp, "BROWSER %s\n", state.wwwbrowser);
  89.   if (state.helpfile) fprintf(fp, "HELPFILE %s\n", state.helpfile);
  90.   if (fclose(fp) != 0) {
  91.     fl_show_alert("Error in closing parameter file", "", "", 1);
  92.   }
  93.   free(rcpath);
  94.   return 0;
  95. }
  96.  
  97.  
  98. /*  Load some default values used by Fitsblink  */
  99. int
  100. load_settings(void)
  101.  
  102. {
  103.   char *home;
  104.   char t[256], *p, *r;
  105.   char *rcpath;
  106.   char *rcname = "/.fitsblinkrc";
  107.   FILE *fp;
  108.  
  109.   /*  Get home directory  */
  110.   home = getenv("HOME");
  111.   /*  Reserve space for full name  */
  112.   rcpath = (char *) myalloc(sizeof(char) * (strlen(home) + strlen(rcname) + 1),
  113.                 "load_settings", "rcpath");
  114.   strcpy(rcpath, home);
  115.   strcat(rcpath, rcname);
  116.   if ((fp = fopen(rcpath, "r")) == NULL) {
  117.     fl_show_alert("Can't open parameter file", "", "", 1);
  118.     return 1;
  119.   }
  120.   while (!feof(fp)) {
  121.     /*  Read one line */
  122.     if (!fgets(t, 256, fp)) break;
  123.     p = t;
  124.     p = strtok(p, " \t\n");
  125.     if (!p) continue;
  126.     if (!strcmp("USNO_PATH", p)) {
  127.       r = strtok(NULL, " \t");
  128.       if (r) {
  129.     trim_spaces(r);
  130.     strncpy(catalog[CAT_USNO].path, r, PATHLENGTH);
  131.       }
  132.     }
  133.     else if (!strcmp("PPM_PATH", p)) {
  134.       r = strtok(NULL, " \t");
  135.       if (r) {
  136.     trim_spaces(r);
  137.     strcpy(catalog[CAT_PPM].path, r);
  138.       }
  139.     }
  140.     else if (!strcmp("GUIDE_NORTH_PATH", p)) {
  141.       r = strtok(NULL, " \t");
  142.       if (r) {
  143.     trim_spaces(r);
  144.     strcpy(catalog[CAT_GUIDE].path, r);
  145.       }
  146.     }
  147.     else if (!strcmp("GUIDE_SOUTH_PATH", p)) {
  148.       r = strtok(NULL, " \t");
  149.       if (r) {
  150.     trim_spaces(r);
  151.     strcpy(catalog[CAT_GUIDE_SOUTH].path, r);
  152.       }
  153.     }
  154.     else if (!strcmp("OBSERVATORY", p)) {
  155.       r = strtok(NULL, " \t");
  156.       if (r) {
  157.     sscanf(r, "%d", &observatory.code);
  158.       }
  159.     }
  160.     else if (!strcmp("OBSERVER", p)) {
  161.       r = strtok(NULL, "\n");
  162.       if (r) {
  163.     trim_spaces(r);
  164.     strncpy(observatory.observer, r, CARDLENGTH);
  165.       }
  166.     }
  167.     else if (!strcmp("TELESCOPE", p)) {
  168.       r = strtok(NULL, "\n");
  169.       if (r) {
  170.     trim_spaces(r);
  171.     strncpy(observatory.telescope, r, CARDLENGTH);
  172.       }
  173.     }
  174.     else if (!strcmp("INSTRUMENT", p)) {
  175.       r = strtok(NULL, "\n");
  176.       if (r) {
  177.     trim_spaces(r);
  178.     strncpy(observatory.instrument, r, CARDLENGTH);
  179.       }
  180.     }
  181.     else if (!strcmp("LONGITUDE", p)) {
  182.       r = strtok(NULL, "\n");
  183.       if (r) {
  184.     trim_spaces(r);
  185.     observatory.longitude = strtod(r, NULL);
  186.       }
  187.     }
  188.     else if (!strcmp("LATITUDE", p)) {
  189.       r = strtok(NULL, "\n");
  190.       if (r) {
  191.     trim_spaces(r);
  192.     observatory.latitude = strtod(r, NULL);
  193.       }
  194.     }
  195.     else if (!strcmp("LOGFILE", p)) {
  196.       r = strtok(NULL, "\n");
  197.       if (r) {
  198.     trim_spaces(r);
  199.     state.logfile = strdup(r);
  200.       }
  201.     }
  202.     else if (!strcmp("TO_ADDRESS", p)) {
  203.       r = strtok(NULL, "\n");
  204.       if (r) {
  205.     trim_spaces(r);
  206.     mail.to = strdup(r);
  207.       }
  208.     }
  209.     else if (!strcmp("CC_ADDRESS", p)) {
  210.       r = strtok(NULL, "\n");
  211.       if (r) {
  212.     trim_spaces(r);
  213.     mail.cc = strdup(r);
  214.       }
  215.     }
  216.     else if (!strcmp("MAIL_TITLE", p)) {
  217.       r = strtok(NULL, "\n");
  218.       if (r) {
  219.     trim_spaces(r);
  220.     mail.title = strdup(r);
  221.       }
  222.     }
  223.     else if (!strcmp("FILE_TO_MAIL", p)) {
  224.       r = strtok(NULL, "\n");
  225.       if (r) {
  226.     trim_spaces(r);
  227.     mail.file = strdup(r);
  228.       }
  229.     }
  230.     else if (!strcmp("COLOR", p)) {
  231.       r = strtok(NULL, "\n");
  232.       if (r) {
  233.     trim_spaces(r);
  234.     state.color = strtol(r, NULL, 10);
  235.       }
  236.     }
  237.     else if (!strcmp("DISPLAY_COLOR", p)) {
  238.       r = strtok(NULL, "\n");
  239.       if (r) {
  240.     trim_spaces(r);
  241.     state.color = strtol(r, NULL, 10);
  242.       }
  243.     }
  244.     else if (!strcmp("INVERSE", p)) {
  245.       r = strtok(NULL, "\n");
  246.       if (r) {
  247.     trim_spaces(r);
  248.     state.inverse = strtol(r, NULL, 10);
  249.       }
  250.     }
  251.     else if (!strcmp("DISPLAY_INVERSE", p)) {
  252.       r = strtok(NULL, "\n");
  253.       if (r) {
  254.     trim_spaces(r);
  255.     state.inverse = strtol(r, NULL, 10);
  256.       }
  257.     }
  258.     else if (!strcmp("DELAY", p)) {
  259.       r = strtok(NULL, "\n");
  260.       if (r) {
  261.     trim_spaces(r);
  262.     state.delay = strtod(r, NULL);
  263.       }
  264.     }
  265.     else if (!strcmp("DISPLAY_DELAY", p)) {
  266.       r = strtok(NULL, "\n");
  267.       if (r) {
  268.     trim_spaces(r);
  269.     state.delay = strtod(r, NULL);
  270.       }
  271.     }
  272.     else if (!strcmp("DISPLAY_AUTOLEVEL_HIGH", p)) {
  273.       r = strtok(NULL, "\n");
  274.       if (r) {
  275.     trim_spaces(r);
  276.     state.autolevel_high = strtod(r, NULL);
  277.       }
  278.     }
  279.     else if (!strcmp("DISPLAY_WIDTH", p)) {
  280.       r = strtok(NULL, "\n");
  281.       if (r) {
  282.     trim_spaces(r);
  283.     state.blinkwidth = strtol(r, NULL, 10);
  284.       }
  285.     }
  286.     else if (!strcmp("DISPLAY_HEIGHT", p)) {
  287.       r = strtok(NULL, "\n");
  288.       if (r) {
  289.     trim_spaces(r);
  290.     state.blinkheight = strtol(r, NULL, 10);
  291.       }
  292.     }
  293.     else if (!strcmp("TEL_START", p)) {
  294.       r = strtok(NULL, "\n");
  295.       if (r) {
  296.     trim_spaces(r);
  297.     strncpy(telescope.start, r, 255);
  298.       }
  299.     }
  300.     else if (!strcmp("TEL_POINT", p)) {
  301.       r = strtok(NULL, "\n");
  302.       if (r) {
  303.     trim_spaces(r);
  304.     strncpy(telescope.point, r, 255);
  305.       }
  306.     }
  307.     else if (!strcmp("TEL_WHERE", p)) {
  308.       r = strtok(NULL, "\n");
  309.       if (r) {
  310.     trim_spaces(r);
  311.     strncpy(telescope.where, r, 255);
  312.       }
  313.     }
  314.     else if (!strcmp("TEL_ZERO", p)) {
  315.       r = strtok(NULL, "\n");
  316.       if (r) {
  317.     trim_spaces(r);
  318.     strncpy(telescope.zero, r, 255);
  319.       }
  320.     }
  321.     else if (!strcmp("TEL_CENTER", p)) {
  322.       r = strtok(NULL, "\n");
  323.       if (r) {
  324.     trim_spaces(r);
  325.     strncpy(telescope.center, r, 255);
  326.       }
  327.     }
  328.     else if (!strcmp("TEL_PARK", p)) {
  329.       r = strtok(NULL, "\n");
  330.       if (r) {
  331.     trim_spaces(r);
  332.     strncpy(telescope.park, r, 255);
  333.       }
  334.     }
  335.     else if (!strcmp("CCD_GETTEMP", p)) {
  336.       r = strtok(NULL, "\n");
  337.       if (r) {
  338.     trim_spaces(r);
  339.     strncpy(telescope.gettemp, r, 255);
  340.       }
  341.     }
  342.     else if (!strcmp("CCD_SETTEMP", p)) {
  343.       r = strtok(NULL, "\n");
  344.       if (r) {
  345.     trim_spaces(r);
  346.     strncpy(telescope.settemp, r, 255);
  347.       }
  348.     }
  349.     else if (!strcmp("CCD_EXPOSE", p)) {
  350.       r = strtok(NULL, "\n");
  351.       if (r) {
  352.     trim_spaces(r);
  353.     strncpy(telescope.expose, r, 255);
  354.       }
  355.     }
  356.     else if (!strcmp("BROWSER", p)) {
  357.       r = strtok(NULL, "\n");
  358.       if (r) {
  359.     trim_spaces(r);
  360.     state.wwwbrowser = strdup(r);
  361.       }
  362.     }
  363.     else if (!strcmp("HELPFILE", p)) {
  364.       r = strtok(NULL, "\n");
  365.       if (r) {
  366.     trim_spaces(r);
  367.     state.helpfile = strdup(r);
  368.       }
  369.     }
  370.     else if (!strcmp("COUNT_SIGMA", p)) {
  371.       r = strtok(NULL, "\n");
  372.       if (r) {
  373.     trim_spaces(r);
  374.     defvals.fits.sg_num = strtod(r, NULL);
  375.       }
  376.     }
  377.     else if (!strcmp("COUNT_MINBRIGHT", p)) {
  378.       r = strtok(NULL, "\n");
  379.       if (r) {
  380.     trim_spaces(r);
  381.     defvals.fits.minbright = strtod(r, NULL);
  382.       }
  383.     }
  384.     else if (!strcmp("COUNT_STARSIZE", p)) {
  385.       r = strtok(NULL, "\n");
  386.       if (r) {
  387.     trim_spaces(r);
  388.     defvals.fits.minstar = strtol(r, NULL, 10);
  389.       }
  390.     }
  391.     else if (!strcmp("COUNT_GRIDSIZE", p)) {
  392.       r = strtok(NULL, "\n");
  393.       if (r) {
  394.     trim_spaces(r);
  395.     defvals.fits.maxsize = strtol(r, NULL, 10);
  396.       }
  397.     }
  398.     else if (!strcmp("COUNT_EDGE", p)) {
  399.       r = strtok(NULL, "\n");
  400.       if (r) {
  401.     trim_spaces(r);
  402.     defvals.fits.border = strtol(r, NULL, 10);
  403.       }
  404.     }
  405.     else if (!strcmp("COUNT_APERTURE", p)) {
  406.       r = strtok(NULL, "\n");
  407.       if (r) {
  408.     trim_spaces(r);
  409.     defvals.fits.aperture = strtol(r, NULL, 10);
  410.       }
  411.     }
  412.     else if (!strcmp("COUNT_INNER", p)) {
  413.       r = strtok(NULL, "\n");
  414.       if (r) {
  415.     trim_spaces(r);
  416.     defvals.fits.inner = strtod(r, NULL);
  417.       }
  418.     }
  419.     else if (!strcmp("COUNT_OUTER", p)) {
  420.       r = strtok(NULL, "\n");
  421.       if (r) {
  422.     trim_spaces(r);
  423.     defvals.fits.outer = strtod(r, NULL);
  424.       }
  425.     }
  426.     else if (!strcmp("MATCH_MIN", p)) {
  427.       r = strtok(NULL, "\n");
  428.       if (r) {
  429.     trim_spaces(r);
  430.     defvals.match.min = strtod(r, NULL);
  431.       }
  432.     }
  433.     else if (!strcmp("MATCH_FIRSTBRIGHT", p)) {
  434.       r = strtok(NULL, "\n");
  435.       if (r) {
  436.     trim_spaces(r);
  437.     defvals.match.firstbright = strtol(r, NULL, 10);
  438.       }
  439.     }
  440.     else if (!strcmp("MATCH_NSTAR", p)) {
  441.       r = strtok(NULL, "\n");
  442.       if (r) {
  443.     trim_spaces(r);
  444.     defvals.match.nstar = strtol(r, NULL, 10);
  445.       }
  446.     }
  447.     else if (!strcmp("MATCH_POSERRMAX", p)) {
  448.       r = strtok(NULL, "\n");
  449.       if (r) {
  450.     trim_spaces(r);
  451.     defvals.match.poserrmax = strtol(r, NULL, 10);
  452.       }
  453.     }
  454.     else if (!strcmp("MATCH_MAXRES", p)) {
  455.       r = strtok(NULL, "\n");
  456.       if (r) {
  457.     trim_spaces(r);
  458.     defvals.match.maxres = strtod(r, NULL);
  459.       }
  460.     }
  461.     else if (!strcmp("MAP_MINMAG", p)) {
  462.       r = strtok(NULL, "\n");
  463.       if (r) {
  464.     trim_spaces(r);
  465.     defvals.map.minmag = strtod(r, NULL);
  466.       }
  467.     }
  468.     else if (!strcmp("MAP_MAXMAG", p)) {
  469.       r = strtok(NULL, "\n");
  470.       if (r) {
  471.     trim_spaces(r);
  472.     defvals.map.maxmag = strtod(r, NULL);
  473.       }
  474.     }
  475.     else {
  476.       trim_spaces(p);
  477.       if (strlen(p) > 0) fprintf(stderr, "Unknown parameter %s ignored.\n", p);
  478.     }
  479.   }
  480.   return 0;   
  481. }             
  482.               
  483.  
  484. /*  Catalog paths  */
  485. /*******************/
  486. void 
  487. usno_path_setC(FL_OBJECT *obj, long val)
  488.  
  489. {
  490.   usnodirC(obj, val);
  491. }
  492.  
  493. void 
  494. ppm_path_setC(FL_OBJECT *obj, long val)
  495.  
  496. {
  497.   ppmdirC(obj, val);
  498. }
  499.  
  500. void 
  501. gsc_north_path_setC(FL_OBJECT *obj, long val)
  502.  
  503. {
  504.   guidedirC(obj, val);
  505. }
  506.  
  507. void 
  508. gsc_south_path_setC(FL_OBJECT *obj, long val)
  509.  
  510. {
  511.   guidedirsouthC(obj, val);
  512. }
  513.  
  514.  
  515. /*  Observatory data  */
  516. /**********************/
  517. void 
  518. telescope_setC(FL_OBJECT *obj, long val)
  519.  
  520. {
  521.   strncpy(observatory.telescope, fl_get_input(obj), CARDLENGTH - 1);
  522. }
  523.  
  524. void 
  525. observatory_setC(FL_OBJECT *obj, long val)
  526.  
  527. {
  528.   int c;
  529.   char a[10];
  530.  
  531.   c = strtol(fl_get_input(obj), NULL, 10);
  532.   sprintf(a, "%d", c);
  533.   fl_set_input(obj, a);
  534.   observatory.code = c;
  535. }
  536.  
  537. void 
  538. observer_setC(FL_OBJECT *obj, long val)
  539.  
  540. {
  541.   strncpy(observatory.observer, fl_get_input(obj), CARDLENGTH - 1);
  542. }
  543.  
  544. void 
  545. instrument_setC(FL_OBJECT *obj, long val)
  546.  
  547. {
  548.   strncpy(observatory.instrument, fl_get_input(obj), CARDLENGTH - 1);
  549. }
  550.  
  551. void 
  552. observatory_longitudeC(FL_OBJECT *obj, long val)
  553.  
  554. {
  555.   char a[15];
  556.  
  557.   observatory.longitude = strtod(fl_get_input(obj), NULL);
  558.   sprintf(a, "%.6f", observatory.longitude);
  559.   fl_set_input(obj, a);
  560. }
  561.  
  562. void 
  563. observatory_latitudeC(FL_OBJECT *obj, long val)
  564.  
  565. {
  566.   char a[15];
  567.  
  568.   observatory.latitude = strtod(fl_get_input(obj), NULL);
  569.   sprintf(a, "%.6f", observatory.latitude);
  570.   fl_set_input(obj, a);
  571. }
  572.  
  573. /*=================*/
  574. /*  Mail defaults  */
  575. /*=================*/
  576. void 
  577. to_setC(FL_OBJECT *obj, long val)
  578.  
  579. {
  580.   toaddressC(obj, val);
  581. }
  582.  
  583. void 
  584. cc_setC(FL_OBJECT *obj, long val)
  585.  
  586. {
  587.   ccaddressC(obj, val);
  588. }
  589.  
  590. void 
  591. subject_setC(FL_OBJECT *obj, long val)
  592.  
  593. {
  594.   mailtitleC(obj, val);
  595. }
  596.  
  597. void 
  598. file_setC(FL_OBJECT *obj, long val)
  599.  
  600. {
  601.   mailfileC(obj, val);
  602. }
  603.  
  604. /*====================*/
  605. /*  Display settings  */
  606. /*====================*/
  607. void 
  608. color_setC(FL_OBJECT *obj, long val){}
  609.  
  610. void 
  611. inverse_setC(FL_OBJECT *obj, long val){}
  612.  
  613. void 
  614. set_autolevel_highC(FL_OBJECT *obj, long val)
  615.  
  616. {
  617.   float autol;
  618.  
  619.   autol = strtod(fl_get_input(obj), NULL);
  620.   if (autol >= 0.02 || autol < 0.003) {
  621.     fl_show_message("Suggestested values for this parameter are between",
  622.           "0.003 and 0.02.",
  623.           "");
  624.   }
  625.   state.autolevel_high = autol;
  626. }
  627.  
  628. void 
  629. blinkerwidthC(FL_OBJECT *obj, long val){}
  630.  
  631. void 
  632. blinkerheightC(FL_OBJECT *obj, long val){}
  633.  
  634. /*==============================================*/
  635. /*  Commands for camera and telescope control   */
  636. /*==============================================*/
  637.  
  638. void
  639. comstartC(FL_OBJECT *obj, long val)
  640.  
  641. {
  642.   strcpy(telescope.start, fl_get_input(obj));
  643. }
  644.  
  645. void
  646. compointC(FL_OBJECT *obj, long val)
  647.  
  648. {
  649.   strcpy(telescope.point, fl_get_input(obj));
  650. }
  651.  
  652. void
  653. comparkC(FL_OBJECT *obj, long val)
  654.  
  655. {
  656.   strcpy(telescope.park, fl_get_input(obj));
  657. }
  658.  
  659. void
  660. comwhereC(FL_OBJECT *obj, long val)
  661.  
  662. {
  663.   strcpy(telescope.where, fl_get_input(obj));
  664. }
  665.  
  666. void
  667. comzeroC(FL_OBJECT *obj, long val)
  668.  
  669. {
  670.   strcpy(telescope.zero, fl_get_input(obj));
  671. }
  672.  
  673. void
  674. comcenterC(FL_OBJECT *obj, long val)
  675.  
  676. {
  677.   strcpy(telescope.center, fl_get_input(obj));
  678. }
  679.  
  680. void
  681. comgettempC(FL_OBJECT *obj, long val)
  682.  
  683. {
  684.   strcpy(telescope.gettemp, fl_get_input(obj));
  685. }
  686.  
  687. void
  688. comsettempC(FL_OBJECT *obj, long val)
  689.  
  690. {
  691.   strcpy(telescope.settemp, fl_get_input(obj));
  692. }
  693.  
  694. void
  695. comexposeC(FL_OBJECT *obj, long val)
  696.  
  697. {
  698.   strcpy(telescope.expose, fl_get_input(obj));
  699. }
  700.  
  701. /*==============================*/
  702. /*  Star detection parameters   */
  703. /*==============================*/
  704.  
  705. void
  706. set_sg_numC(FL_OBJECT *obj, long val)
  707.  
  708. {
  709.   defvals.fits.sg_num = proc_sg_num(obj, defvals.fits.sg_num);
  710. }
  711.  
  712. void
  713. set_minbrightC(FL_OBJECT *obj, long val)
  714.  
  715. {
  716.   defvals.fits.minbright = proc_minbright(obj, defvals.fits.minbright);
  717. }
  718.  
  719. void
  720. set_minstarC(FL_OBJECT *obj, long val)
  721.  
  722. {
  723.   defvals.fits.minstar = proc_minstar(obj, defvals.fits.minstar);
  724. }
  725.  
  726. void
  727. set_gridsizeC(FL_OBJECT *obj, long val)
  728.  
  729. {
  730.   defvals.fits.maxsize = proc_gridsize(obj, defvals.fits.maxsize);
  731. }
  732.  
  733. void
  734. set_borderC(FL_OBJECT *obj, long val)
  735.  
  736. {
  737.   defvals.fits.border = proc_border(obj, defvals.fits.border);
  738. }
  739.  
  740. void
  741. set_apertureC(FL_OBJECT *obj, long val)
  742.  
  743. {
  744.   defvals.fits.aperture = fl_get_button(obj);
  745. }
  746.  
  747. void
  748. set_innerC(FL_OBJECT *obj, long val)
  749.  
  750. {
  751.   defvals.fits.inner = proc_inner(obj, defvals.fits.inner, defvals.fits.outer);
  752. }
  753.  
  754. void
  755. set_outerC(FL_OBJECT *obj, long val)
  756.  
  757. {
  758.   defvals.fits.outer = proc_outer(obj, defvals.fits.outer, defvals.fits.inner);
  759. }
  760.  
  761. /*===================*/
  762. /* Catalog matching  */
  763. /*===================*/
  764. void
  765. set_minconstC(FL_OBJECT *obj, long val)
  766.  
  767. {
  768.   defvals.match.min = proc_min(obj, defvals.match.min, defvals.match.nstar);
  769. }
  770.  
  771. void
  772. set_initconstC(FL_OBJECT *obj, long val)
  773.  
  774. {
  775.   defvals.match.firstbright = proc_firstbright(obj, defvals.match.firstbright);
  776. }
  777.  
  778. void
  779. set_starconstC(FL_OBJECT *obj, long val)
  780.  
  781. {
  782.   defvals.match.nstar = proc_nstar(obj, defvals.match.nstar);
  783. }
  784.  
  785.  
  786. void
  787. set_starerrorC(FL_OBJECT *obj, long val)
  788.  
  789. {
  790.   defvals.match.poserrmax = proc_poserrmax(obj, defvals.match.poserrmax);
  791. }
  792.  
  793.  
  794. void
  795. set_maxresC(FL_OBJECT *obj, long val)
  796.  
  797. {
  798.   defvals.match.maxres = proc_maxres(obj, defvals.match.maxres);
  799. }
  800.  
  801. void
  802. set_minmagC(FL_OBJECT *obj, long val)
  803.  
  804. {
  805.   defvals.map.minmag = proc_minmag(obj, defvals.map.minmag, defvals.map.maxmag);
  806. }
  807.  
  808. void
  809. set_maxmagC(FL_OBJECT *obj, long val)
  810.  
  811. {
  812.   defvals.map.maxmag = proc_maxmag(obj, defvals.map.maxmag, defvals.map.minmag);
  813. }
  814.  
  815.  
  816.  
  817. /***************************/
  818. /*  WWW browser path       */
  819. /***************************/
  820. void
  821. setbrowserC(FL_OBJECT *obj, long val)
  822.  
  823. {
  824.   if (state.wwwbrowser) free(state.wwwbrowser);
  825.   state.wwwbrowser = strdup((char *)fl_get_input(obj));
  826. }
  827.  
  828. void
  829. sethelpfileC(FL_OBJECT *obj, long val)
  830.  
  831. {
  832.   if (state.helpfile) free(state.helpfile);
  833.   state.helpfile = strdup((char *)fl_get_input(obj));
  834. }
  835.  
  836.  
  837.  
  838. void
  839. show_settings(FL_OBJECT *obj, int m)
  840.  
  841. {
  842.   char a[10];
  843.   int out;
  844.   XEvent event;
  845.   FL_OBJECT *o;
  846.  
  847.   /*  The window in not created yet, do it now  */
  848.   if (state.settings == NULL) {
  849.     state.settings = create_form_Settings();
  850.     state.set_catalogs = create_form_Set_catalogs();
  851.     state.set_observatory = create_form_Set_observatory();
  852.     state.set_display = create_form_Set_display();
  853.     state.set_mail = create_form_Set_mail();
  854.     state.set_help = create_form_Set_help();
  855.     state.set_commands = create_form_Commands();
  856.     state.set_ccd = create_form_Set_ccd();
  857.     state.set_count = create_form_Set_count();
  858.     state.set_match = create_form_Set_match();
  859.     fl_addto_tabfolder(state.settings->setfolderW, "Catalogs", 
  860.                state.set_catalogs->Set_catalogs);
  861.     fl_addto_tabfolder(state.settings->setfolderW, "Observatory", 
  862.                state.set_observatory->Set_observatory);
  863.     fl_addto_tabfolder(state.settings->setfolderW, "Display", 
  864.                state.set_display->Set_display);
  865.     fl_addto_tabfolder(state.settings->setfolderW, "Mail", 
  866.                state.set_mail->Set_mail);
  867.     fl_addto_tabfolder(state.settings->setfolderW, "Telescope", 
  868.                state.set_commands->Commands);
  869.     fl_addto_tabfolder(state.settings->setfolderW, "Camera", 
  870.                state.set_ccd->Set_ccd);
  871.     fl_addto_tabfolder(state.settings->setfolderW, "Count", 
  872.                state.set_count->Set_count);
  873.     fl_addto_tabfolder(state.settings->setfolderW, "Match", 
  874.                state.set_match->Set_match);
  875.     fl_addto_tabfolder(state.settings->setfolderW, "Help", 
  876.                state.set_help->Set_help);
  877.     fl_set_counter_bounds(state.set_display->set_deltatW, 0.0, 5.0);
  878.     fl_set_counter_value(state.set_display->set_deltatW,  
  879.              fl_get_counter_value(state.blinker->deltatW));
  880.     fl_set_counter_step(state.set_display->set_deltatW, 0.1, 0.1);
  881.   }
  882.   fl_show_form(state.settings->Settings,  FL_FIX_SIZE, FL_FULLBORDER | FL_PLACE_FREE_CENTER, "Image options");
  883.   /*==============*/
  884.   /*  Catalogs    */
  885.   /*==============*/
  886.   fl_set_input(state.set_catalogs->usno_pathW, catalog[CAT_USNO].path);
  887.   fl_set_input(state.set_catalogs->ppm_pathW, catalog[CAT_PPM].path);
  888.   fl_hide_object(state.set_catalogs->ppm_pathW);
  889.   fl_set_input(state.set_catalogs->gsc_north_pathW, catalog[CAT_GUIDE].path);
  890.   fl_set_input(state.set_catalogs->gsc_south_pathW, catalog[CAT_GUIDE_SOUTH].path);
  891.   /*==============*/
  892.   /*  Observatory */
  893.   /*==============*/
  894.   fl_set_input(state.set_observatory->telescopeW, observatory.telescope);
  895.   sprintf(a, "%d", observatory.code);
  896.   fl_set_input(state.set_observatory->observatoryW, a);
  897.   fl_set_input(state.set_observatory->observerW, observatory.observer);
  898.   fl_set_input(state.set_observatory->instrumentW, observatory.instrument);
  899.   sprintf(a, "%.6f", observatory.longitude);
  900.   fl_set_input(state.set_observatory->observatory_longitudeW, a);
  901.   sprintf(a, "%.6f", observatory.latitude);
  902.   fl_set_input(state.set_observatory->observatory_latitudeW, a);
  903.   /*==============*/
  904.   /*  Mail        */
  905.   /*==============*/
  906.   fl_set_input(state.set_mail->toW, mail.to);
  907.   fl_set_input(state.set_mail->ccW, mail.cc);
  908.   fl_set_input(state.set_mail->subjectW, mail.title);
  909.   fl_set_input(state.set_mail->fileW, mail.file);
  910.   /*==============*/
  911.   /*  Display     */
  912.   /*==============*/
  913.   fl_set_button(state.set_display->color_setW, state.color);
  914.   fl_set_button(state.set_display->inverse_setW, state.inverse);
  915.   fl_set_button(state.set_display->set_deltatW, state.delay);
  916.   sprintf(a, "%.3f", state.autolevel_high);
  917.   fl_set_input(state.set_display->set_autolevel_highW, a);
  918.   sprintf(a, "%d", state.blinkwidth);
  919.   fl_set_input(state.set_display->blinkerwidthW, a);
  920.   fl_deactivate_object(state.set_display->blinkerwidthW);
  921.   sprintf(a, "%d", state.blinkheight);
  922.   fl_set_input(state.set_display->blinkerheightW, a);
  923.   fl_deactivate_object(state.set_display->blinkerheightW);
  924.   /*========================*/
  925.   /*  Telescope and camera  */
  926.   /*========================*/
  927.   fl_set_input(state.set_commands->comstartW, telescope.start);
  928.   fl_set_input(state.set_commands->comparkW, telescope.park);
  929.   fl_set_input(state.set_commands->compointW, telescope.point);
  930.   fl_set_input(state.set_commands->comwhereW, telescope.where);
  931.   fl_set_input(state.set_commands->comzeroW, telescope.zero);
  932.   fl_set_input(state.set_commands->comcenterW, telescope.center);
  933.   fl_set_input(state.set_ccd->comgettempW, telescope.gettemp);
  934.   fl_set_input(state.set_ccd->comsettempW, telescope.settemp);
  935.   fl_set_input(state.set_ccd->comexposeW, telescope.expose);
  936.   /*===================*/
  937.   /*  Star detection   */
  938.   /*===================*/
  939.   sprintf(a, "%.1f", defvals.fits.sg_num);
  940.   fl_set_input(state.set_count->set_sg_numW, a);
  941.   sprintf(a, "%.0f", defvals.fits.minbright);
  942.   fl_set_input(state.set_count->set_minbrightW, a);
  943.   sprintf(a, "%d", defvals.fits.maxsize);
  944.   fl_set_input(state.set_count->set_gridsizeW, a);
  945.   sprintf(a, "%d", defvals.fits.minstar);
  946.   fl_set_input(state.set_count->set_minstarW, a);
  947.   sprintf(a, "%d", defvals.fits.border);
  948.   fl_set_input(state.set_count->set_borderW, a);
  949.   fl_set_button(state.set_count->set_apertureW, defvals.fits.aperture);
  950.   sprintf(a, "%.1f", defvals.fits.inner);
  951.   fl_set_input(state.set_count->set_innerW, a);
  952.   sprintf(a, "%.1f", defvals.fits.outer);
  953.   fl_set_input(state.set_count->set_outerW, a);
  954.   /*===================*/
  955.   /*  Catalog matching */
  956.   /*===================*/
  957.   sprintf(a, "%.1f", defvals.match.min);
  958.   fl_set_input(state.set_match->set_minconstW, a);
  959.   sprintf(a, "%d", defvals.match.firstbright);
  960.   fl_set_input(state.set_match->set_initconstW, a);
  961.   sprintf(a, "%d", defvals.match.nstar);
  962.   fl_set_input(state.set_match->set_starconstW, a);
  963.   sprintf(a, "%.1f", defvals.match.poserrmax);
  964.   fl_set_input(state.set_match->set_starerrorW, a);
  965.   sprintf(a, "%.1f", defvals.match.maxres);
  966.   fl_set_input(state.set_match->set_maxresW, a);
  967.   sprintf(a, "%.1f", defvals.map.minmag);
  968.   fl_set_input(state.set_match->set_minmagW, a);
  969.   sprintf(a, "%.1f", defvals.map.maxmag);
  970.   fl_set_input(state.set_match->set_maxmagW, a);
  971.   /*==============*/
  972.   /*  Help        */
  973.   /*==============*/
  974.   if (state.wwwbrowser) fl_set_input(state.set_help->setbrowserW, state.wwwbrowser);
  975.   if (state.helpfile) fl_set_input(state.set_help->sethelpfileW, state.helpfile);
  976.  
  977.   out = 0;
  978.   do {
  979.     o = fl_check_forms();
  980.     if (o == FL_EVENT) {
  981.       fl_XNextEvent(&event);
  982.     }
  983.     else if (o == state.settings->savesettingsW) {
  984.       save_settings();
  985.       out = 1;
  986.     }
  987.     else if (o == state.settings->closesettingsW) {
  988.       out = 1;
  989.     }
  990.   } while(!out);
  991.   fl_hide_form(state.settings->Settings);
  992. }
  993.