home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / modelers / geomview / source.lha / Geomview / src / lib / forms / FORMS-2.0-PATCHES < prev    next >
Encoding:
Text File  |  1993-10-29  |  83.0 KB  |  2,951 lines
  1. Summary of changes made to FORMS 2.0, through October 1993,
  2. at the Geometry Center.
  3.  
  4.  
  5. FORMS/colorwheel.c:
  6.     New color-picker module.
  7.  
  8. FORMS/fouraxis.c:
  9.     New module, derived from positioner.c.
  10.     Allows specifying a direction in 4-space.
  11.  
  12.  
  13. FORMS/objects.c:
  14.     Be more intelligent about frozen forms: only redraw if
  15.     some object changed while the form was frozen.
  16.     Use the sign bit of the form->frozen field to tell.
  17.  
  18. FORMS/browser.c:
  19.     Add '@I' prefix to embed FL_ICON_STYLE (symbol font) items in a browser.
  20.  
  21. FORMS/draw.c:
  22.     Tie mouse (x,y) position to all mouse clicks.  Use this to ensure that we
  23.     always register a mouse click in its correct position, not the place where
  24.     the mouse lies when we get a chance to read it!
  25.     Click position is fed to the next caller to ask for the mouse position
  26.     after a click; later calls read the live mouse position.  Seems to work.
  27.  
  28.     Cache stuff as much as possible.  Don't load fonts or read color map unless
  29.     (until) we actually need them.  Might allow programs to start up at
  30.     a reasonable speed, since the SGI font manager is slower in 4.0.x than 3.3.
  31.  
  32.     Handle Icon font usefully -- use the Symbol font, and allow it to be scaled.
  33.  
  34.     Accommodate new font-sizing rule in IRIX 4.0.5: fonts are now
  35.     scaled to constant real size rather than constant size in pixels.
  36.     On IRIX 4.0.5 or greater, we discover the error this will cause and
  37.     scale all font sizes by its reciprocal (!).
  38.  
  39.  
  40. FORMS/forms.c:
  41.     More of record-mouse-position-on-click mod mentioned under draw.c.
  42.  
  43.     Cut out so-called Correction for Irix 4.0 INPUTCHANGE Bug.
  44.     With the bugfix installed, FORMS seems to lose inputchange's for new
  45.     windows appearing under the cursor; without it, it sees them correctly.
  46.  
  47. FORMS/bitmap.c:
  48.     Optimize drawing bitmaps.  Cache fl_getmcolor() values; use pointers
  49.     to scan input & output pixel arrays.  ~sixfold speedup.
  50.     Save 64K of static data.
  51.  
  52.  
  53. DESIGN/Makefile:
  54.     Add rule for fdesign2c, batch-mode translator from *.fd to *.{c,h}.
  55.  
  56. DESIGN/fd_forms.c:
  57. DESIGN/fd_main.c:
  58. DESIGN/fd_main.h:
  59.     Adapt to allow batch mode.
  60.  
  61. DESIGN/fd_objects.c:
  62.     Added colorwheel and fouraxis objects.
  63.  
  64. DESIGN/formsstubs.c:
  65.     Stubs for FORMS routines -- used for batch-mode fdesign2c program.
  66.  
  67.  
  68.  
  69. diff -r -c orig/DEMOS/Makefile new/DEMOS/Makefile
  70. *** orig/DEMOS/Makefile    Thu Nov 28 02:22:04 1991
  71. --- new/DEMOS/Makefile    Mon Aug 10 12:57:18 1992
  72. ***************
  73. *** 15,21 ****
  74.       demo21.o demo22.o demo23.o demo24.o demo25.o \
  75.       demo26.o demo27.o demo28.o demo29.o demo30.o \
  76.       demo31.o demo32.o demo33.o demo34.o demo35.o \
  77. !     demo36.o demo37.o demo38.o
  78.   #
  79.   DEMOS= ${DEMOSO:.o=}
  80.   
  81. --- 15,22 ----
  82.       demo21.o demo22.o demo23.o demo24.o demo25.o \
  83.       demo26.o demo27.o demo28.o demo29.o demo30.o \
  84.       demo31.o demo32.o demo33.o demo34.o demo35.o \
  85. !     demo36.o demo37.o demo38.o \
  86. !     demof01.o demof02.o
  87.   #
  88.   DEMOS= ${DEMOSO:.o=}
  89.   
  90. diff -r -c orig/DEMOS/Readme new/DEMOS/Readme
  91. *** orig/DEMOS/Readme    Mon Nov 18 13:26:09 1991
  92. --- new/DEMOS/Readme    Mon Aug 10 19:01:55 1992
  93. ***************
  94. *** 50,52 ****
  95. --- 50,56 ----
  96.   demo36    A demo of counters.
  97.   demo37    A strip chart.
  98.   demo38    All charts.
  99. + 
  100. + demof01    Fouraxis demo: fouraxis and numerical display
  101. + demof02 Fouraxis demo: fouraxis and basis-matrix display
  102. + 
  103. diff -r -c orig/DEMOS/demo.menu new/DEMOS/demo.menu
  104. *** orig/DEMOS/demo.menu    Tue Nov  5 06:39:04 1991
  105. --- new/DEMOS/demo.menu    Mon Aug 10 12:36:21 1992
  106. ***************
  107. *** 44,49 ****
  108. --- 44,51 ----
  109.           @other:Choice\nObjects:demo32
  110.           @other:Bitmaps:demo33
  111.           @other:Timer\nObjects:demo34
  112. +         @other:4-D Axis:demof01
  113. +         @other:4-D Axis\n+ Basis:demof02
  114.   
  115.   @main:Attributes:@attribs
  116.       @attribs:All\nBoxtypes:demo17
  117. Only in new/DEMOS: demof01.c
  118. Only in new/DEMOS: demof02.c
  119. diff -r -c orig/DESIGN/Makefile new/DESIGN/Makefile
  120. *** orig/DESIGN/Makefile    Wed Nov 27 09:51:42 1991
  121. --- new/DESIGN/Makefile    Mon Aug 31 11:01:18 1992
  122. ***************
  123. *** 9,24 ****
  124.   #
  125.   # Change the following for correct installation
  126.   #
  127. ! DIR= /usr/sbin
  128.   #
  129.   FILEo = fd_rubber.o fd_select.o fd_names.o fd_objects.o fd_attribs.o \
  130.           fd_forms.o fd_groups.o fd_file.o fd_print.o fd_theforms.o \
  131. !     fd_help.o fd_main.o
  132.   
  133.   all:    fdesign conv15to20
  134.   
  135.   fdesign: $(FILEo)
  136. !     ${CC} ${CFLAGS} ${LDFLAGS} $(FILEo) -o fdesign ${LIBS}
  137.   
  138.   conv15to20: conv15to20.o
  139.       ${CC} conv15to20.o -o conv15to20 -s
  140. --- 9,30 ----
  141.   #
  142.   # Change the following for correct installation
  143.   #
  144. ! DIR= /usr/local/bin
  145.   #
  146. + # Note fd_main.c in the following list.
  147. + # This forces recompilation with the appropriate -DBATCH setting.
  148. + 
  149.   FILEo = fd_rubber.o fd_select.o fd_names.o fd_objects.o fd_attribs.o \
  150.           fd_forms.o fd_groups.o fd_file.o fd_print.o fd_theforms.o \
  151. !     fd_help.o fd_main.c
  152.   
  153.   all:    fdesign conv15to20
  154.   
  155.   fdesign: $(FILEo)
  156. !     ${CC} ${CFLAGS} ${LDFLAGS} $(FILEo) -o $@ ${LIBS}
  157. ! 
  158. ! fdesign2c:  $(FILEo) formsstubs.o
  159. !     ${CC} -DBATCH ${CFLAGS} ${LDFLAGS} ${FILEo} formsstubs.o -o $@ -lforms -lm -lc_s
  160.   
  161.   conv15to20: conv15to20.o
  162.       ${CC} conv15to20.o -o conv15to20 -s
  163. diff -r -c orig/DESIGN/fd_forms.c new/DESIGN/fd_forms.c
  164. *** orig/DESIGN/fd_forms.c    Wed Dec 11 10:35:17 1991
  165. --- new/DESIGN/fd_forms.c    Thu May 28 13:56:47 1992
  166. ***************
  167. *** 155,161 ****
  168.     LOADING AND SAVING
  169.   ****/
  170.   
  171. ! void load_forms(int merge, char *str)
  172.   /* loads or merges a file with form definitions */
  173.   {
  174.     int i,magic;
  175. --- 155,161 ----
  176.     LOADING AND SAVING
  177.   ****/
  178.   
  179. ! int load_forms(int merge, char *str)
  180.   /* loads or merges a file with form definitions */
  181.   {
  182.     int i,magic;
  183. ***************
  184. *** 168,174 ****
  185.       ff = fl_show_file_selector("Filename to merge forms from","","*.fd","");
  186.     else
  187.       ff = fl_show_file_selector("Filename to load forms from","","*.fd","");
  188. !   if (ff == NULL || ff[0] == '\0') return;
  189.     /* Append .fd if required. */
  190.     strcpy(fname,ff);
  191.     i = strlen(fname) -1;
  192. --- 168,174 ----
  193.       ff = fl_show_file_selector("Filename to merge forms from","","*.fd","");
  194.     else
  195.       ff = fl_show_file_selector("Filename to load forms from","","*.fd","");
  196. !   if (ff == NULL || ff[0] == '\0') return 0;
  197.     /* Append .fd if required. */
  198.     strcpy(fname,ff);
  199.     i = strlen(fname) -1;
  200. ***************
  201. *** 176,187 ****
  202.       strcat(fname,".fd");
  203.     /* Open the file for reading */
  204.     fn = fopen(fname,"r");
  205. !   if (fn == (FILE *) NULL) { fl_show_message("No such file!!","",""); return; }
  206.     /* Read in the definitions */
  207.     if (!merge) { fnumb = 0; fl_clear_browser(formbrowser);}
  208.     magic = 0;
  209.     fscanf(fn,"Magic: %d\n\n",&magic);
  210. !   if (magic != 12321) { fl_show_message("Wrong type of file!!","",""); return; }
  211.     fscanf(fn,"Internal Form Definition File\n");
  212.     fscanf(fn,"    (do not change)\n\n");
  213.     fscanf(fn,"Number of forms: %d\n",&i);
  214. --- 176,187 ----
  215.       strcat(fname,".fd");
  216.     /* Open the file for reading */
  217.     fn = fopen(fname,"r");
  218. !   if (fn == (FILE *) NULL) { fl_show_message("No such file!!",fname,""); return 0; }
  219.     /* Read in the definitions */
  220.     if (!merge) { fnumb = 0; fl_clear_browser(formbrowser);}
  221.     magic = 0;
  222.     fscanf(fn,"Magic: %d\n\n",&magic);
  223. !   if (magic != 12321) { fl_show_message("Wrong type of file!!",fname,""); return 0; }
  224.     fscanf(fn,"Internal Form Definition File\n");
  225.     fscanf(fn,"    (do not change)\n\n");
  226.     fscanf(fn,"Number of forms: %d\n",&i);
  227. ***************
  228. *** 194,200 ****
  229.       fl_add_browser_line(formbrowser,forms[fnumb].fname);
  230.       fnumb++;
  231.     }
  232. !   if (i>0) fl_show_message("Not all forms could be loaded!!","","");
  233.     if (i == 0 && !merge)
  234.     {
  235.       fscanf(fn,"\n==============================\n");
  236. --- 194,200 ----
  237.       fl_add_browser_line(formbrowser,forms[fnumb].fname);
  238.       fnumb++;
  239.     }
  240. !   if (i>0) fl_show_message("Not all forms could be loaded!!",fname,"");
  241.     if (i == 0 && !merge)
  242.     {
  243.       fscanf(fn,"\n==============================\n");
  244. ***************
  245. *** 204,212 ****
  246.     if (fnumb>0) set_form(0); else set_form(-1);
  247.     if (merge) changed = 1;
  248.     fclose(fn);
  249.   }
  250.   
  251. ! int save_forms()
  252.   /* saves the form definitions, retunrs whether saved */
  253.   {
  254.     int i,j;
  255. --- 204,213 ----
  256.     if (fnumb>0) set_form(0); else set_form(-1);
  257.     if (merge) changed = 1;
  258.     fclose(fn);
  259. +   return 1;
  260.   }
  261.   
  262. ! int save_forms(int do_fd, char *dfname)
  263.   /* saves the form definitions, retunrs whether saved */
  264.   {
  265.     int i,j;
  266. ***************
  267. *** 213,229 ****
  268.     FILE *fn;
  269.     char fname[256], filename[256], *ff;
  270.   
  271. !   /* Get the file name */
  272. !   ff = fl_show_file_selector("Filename to save forms to","","*.fd","");
  273. !   if (ff == NULL || ff[0] == '\0')
  274. !     { fl_show_message("No forms were saved.","",""); return 0; }
  275.   
  276.     /* Remove .fd is required */
  277. -   strcpy(filename,ff);
  278.     i = strlen(filename) -1;
  279.     if (filename[i] == 'd' && filename[i-1] == 'f' && filename[i-2] == '.')
  280.       filename[i-2] = '\0';
  281.   
  282.     /* Make the .h file. */
  283.     strcpy(fname,filename);
  284.     strcat(fname,".h");
  285. --- 214,251 ----
  286.     FILE *fn;
  287.     char fname[256], filename[256], *ff;
  288.   
  289. !   if(dfname == NULL) {
  290. !     /* Get the file name */
  291. !     ff = fl_show_file_selector("Filename to save forms to","","*.fd","");
  292. !     if (ff == NULL || ff[0] == '\0')
  293. !       { fl_show_message("No forms were saved.","",""); return 0; }
  294. !     strcpy(filename, ff);
  295. !   } else {
  296. !     strcpy(filename, dfname);
  297. !   }
  298.   
  299.     /* Remove .fd is required */
  300.     i = strlen(filename) -1;
  301.     if (filename[i] == 'd' && filename[i-1] == 'f' && filename[i-2] == '.')
  302.       filename[i-2] = '\0';
  303.   
  304. +   /* Make the .fd file. */
  305. +   if(do_fd) {
  306. +     strcpy(fname,filename);
  307. +     strcat(fname,".fd");
  308. +     fn = fopen(fname,"w");
  309. +     if (fn == (FILE *) NULL)
  310. +     { fl_show_message("Cannot create definition file!!","",""); return 0; }
  311. +     fprintf(fn,"Magic: 12321\n\n");
  312. +     fprintf(fn,"Internal Form Definition File\n");
  313. +     fprintf(fn,"    (do not change)\n\n");
  314. +     fprintf(fn,"Number of forms: %d\n",fnumb);
  315. +     for (i=0; i<fnumb; i++) write_form(fn,forms[i].form,forms[i].fname);
  316. +     fprintf(fn,"\n==============================\n%s\n",main_name);
  317. +     fclose(fn);
  318. +     sleep(1);        /* Ensure .fd older than .h and .c */
  319. +   }
  320. + 
  321.     /* Make the .h file. */
  322.     strcpy(fname,filename);
  323.     strcat(fname,".h");
  324. ***************
  325. *** 256,275 ****
  326.     fprintf(fn,"void %s()\n{\n",main_name);
  327.     for (i=0; i<fnumb; i++) fprintf(fn,"  create_form_%s();\n",forms[i].fname);
  328.     fprintf(fn,"}\n\n");
  329. -   fclose(fn);
  330. - 
  331. -   /* Make the .fd file. */
  332. -   strcpy(fname,filename);
  333. -   strcat(fname,".fd");
  334. -   fn = fopen(fname,"w");
  335. -   if (fn == (FILE *) NULL)
  336. -     { fl_show_message("Cannot create definition file!!","",""); return 0; }
  337. -   fprintf(fn,"Magic: 12321\n\n");
  338. -   fprintf(fn,"Internal Form Definition File\n");
  339. -   fprintf(fn,"    (do not change)\n\n");
  340. -   fprintf(fn,"Number of forms: %d\n",fnumb);
  341. -   for (i=0; i<fnumb; i++) write_form(fn,forms[i].form,forms[i].fname);
  342. -   fprintf(fn,"\n==============================\n%s\n",main_name);
  343.     fclose(fn);
  344.     return 1;
  345.   }
  346. --- 278,283 ----
  347. diff -r -c orig/DESIGN/fd_main.c new/DESIGN/fd_main.c
  348. *** orig/DESIGN/fd_main.c    Tue Dec 24 03:47:13 1991
  349. --- new/DESIGN/fd_main.c    Tue Apr 28 17:35:13 1992
  350. ***************
  351. *** 76,82 ****
  352.     {
  353.       rep = fl_show_choice("WARNING","Changes have not been saved.","",
  354.               3,"Save","Exit","Return");
  355. !     if (rep == 1) { if (! save_forms()) return; }
  356.       else if (rep == 3) return;
  357.     }
  358.     exit(0);
  359. --- 76,82 ----
  360.     {
  361.       rep = fl_show_choice("WARNING","Changes have not been saved.","",
  362.               3,"Save","Exit","Return");
  363. !     if (rep == 1) { if (! save_forms(1, NULL)) return; }
  364.       else if (rep == 3) return;
  365.     }
  366.     exit(0);
  367. ***************
  368. *** 110,116 ****
  369.   
  370.   void saveforms_cb(FL_OBJECT *obj, long arg) 
  371.   /* Save the current set of forms. */
  372. !   { changed = ! save_forms(); }
  373.   
  374.   void loadforms_cb(FL_OBJECT *obj, long arg) 
  375.   /* Load a new set of forms */
  376. --- 110,116 ----
  377.   
  378.   void saveforms_cb(FL_OBJECT *obj, long arg) 
  379.   /* Save the current set of forms. */
  380. !   { changed = ! save_forms(1, NULL); }
  381.   
  382.   void loadforms_cb(FL_OBJECT *obj, long arg) 
  383.   /* Load a new set of forms */
  384. ***************
  385. *** 118,124 ****
  386.     if (changed)
  387.     {
  388.       if (fl_show_question("Forms have been changed!","Should I save them?",""))
  389. !       { if (!save_forms()) return; }
  390.     }
  391.     load_forms(FALSE,NULL);
  392.     changed = 0;
  393. --- 118,124 ----
  394.     if (changed)
  395.     {
  396.       if (fl_show_question("Forms have been changed!","Should I save them?",""))
  397. !       { if (!save_forms(1, NULL)) return; }
  398.     }
  399.     load_forms(FALSE,NULL);
  400.     changed = 0;
  401. ***************
  402. *** 153,158 ****
  403. --- 153,159 ----
  404.     fl_activate_form(controlform);
  405.   }
  406.   
  407. + #ifndef BATCH
  408.   void main_loop()
  409.   /* The main event handling loop. */
  410.   {
  411. ***************
  412. *** 212,217 ****
  413. --- 213,219 ----
  414.       }
  415.     }
  416.   }
  417. + #endif /*!BATCH*/
  418.   
  419.   /* declarations to support use of getopt() system call */
  420.   extern char *optarg;
  421. ***************
  422. *** 273,278 ****
  423. --- 275,292 ----
  424.     redraw_the_form(1);
  425.     fl_show_form(controlform,FL_PLACE_POSITION,FALSE,NULL);
  426.   
  427. + #ifdef BATCH
  428. +   i = 0;
  429. +   while(optind < ac) {
  430. +     fprintf(stderr, "%s: ", av[optind]);
  431. +     if(load_forms(FALSE, av[optind]) && save_forms(0, av[optind]))
  432. +     fprintf(stderr, "done.\n");
  433. +     else i = 1;
  434. +     optind++;
  435. +   }
  436. +   exit(i);
  437. + 
  438. + #else /* !BATCH */
  439.     /* Load a file */
  440.     if (optind < ac)
  441.     {
  442. ***************
  443. *** 282,285 ****
  444. --- 296,300 ----
  445.   
  446.     /* Main loop */
  447.     main_loop();
  448. + #endif /* !BATCH */
  449.   }
  450. diff -r -c orig/DESIGN/fd_main.h new/DESIGN/fd_main.h
  451. *** orig/DESIGN/fd_main.h    Wed Dec 11 10:02:23 1991
  452. --- new/DESIGN/fd_main.h    Tue Apr 28 17:29:39 1992
  453. ***************
  454. *** 160,169 ****
  455.   /* Redraws the current form. The argument indicates whether the background
  456.      should be redrawn. */
  457.   
  458. ! void load_forms(int, char *);
  459.   /* loads the forms from a file */
  460.   
  461. ! int save_forms();
  462.   /* saves the forms to a file, returns whether actually saved */
  463.   
  464.   /******** fd_groups.c *********/
  465. --- 160,169 ----
  466.   /* Redraws the current form. The argument indicates whether the background
  467.      should be redrawn. */
  468.   
  469. ! int load_forms(int merge, char *fname);
  470.   /* loads the forms from a file */
  471.   
  472. ! int save_forms(int do_fd, char *fname);
  473.   /* saves the forms to a file, returns whether actually saved */
  474.   
  475.   /******** fd_groups.c *********/
  476. diff -r -c orig/DESIGN/fd_objects.c new/DESIGN/fd_objects.c
  477. *** orig/DESIGN/fd_objects.c    Thu Dec 12 03:41:01 1991
  478. --- new/DESIGN/fd_objects.c    Wed Dec 30 19:05:58 1992
  479. ***************
  480. *** 221,226 ****
  481. --- 221,235 ----
  482.       add_type_def(FL_TIMER,FL_HIDDEN_TIMER,"HIDDEN_TIMER");
  483.   
  484.   /* ADD NEW CLASSES HERE (and in the routine add_an_object below). */
  485. + 
  486. +   fl_add_browser_line(objectbrowser,"fouraxis");
  487. +   add_class_def(FL_FOURAXIS,"fouraxis",fl_create_fouraxis);
  488. +   add_type_def(FL_FOURAXIS,FL_NORMAL_FOURAXIS,"NORMAL_FOURAXIS");
  489. + 
  490. +   fl_add_browser_line(objectbrowser, "colorwheel");
  491. +   add_class_def(FL_COLORWHEEL, "colorwheel", fl_create_colorwheel);
  492. +   add_type_def(FL_COLORWHEEL, FL_NORMAL_COLORWHEEL, "NORMAL_COLORWHEEL");
  493. + 
  494.   } 
  495.   
  496.   /****
  497. ***************
  498. *** 342,348 ****
  499.       break;
  500.       case FL_TIMER:
  501.       obj = fl_add_timer(FL_NORMAL_TIMER,x,y,w,h,"Timer"); break;
  502. !     default:
  503.       fl_show_message("Error","","Trying to add unknow object type.");
  504.       exit(1);
  505.   /*
  506. --- 351,362 ----
  507.       break;
  508.       case FL_TIMER:
  509.       obj = fl_add_timer(FL_NORMAL_TIMER,x,y,w,h,"Timer"); break;
  510. !     case FL_FOURAXIS:
  511. !     obj = fl_add_fouraxis(FL_NORMAL_FOURAXIS, x,y,w,h,"4D axis"); break;
  512. !     case FL_COLORWHEEL:
  513. !     obj = fl_add_colorwheel(FL_NORMAL_COLORWHEEL,x,y,w,h,"Colorwheel");
  514. !     break;
  515. !      default:
  516.       fl_show_message("Error","","Trying to add unknow object type.");
  517.       exit(1);
  518.   /*
  519. Only in new/DESIGN: formsstubs.c
  520. Only in new/DOC/CLASSES: colorwheel.tex
  521. Only in new/DOC/CLASSES: fouraxis.tex
  522. diff -r -c orig/DOC/part3.tex new/DOC/part3.tex
  523. *** orig/DOC/part3.tex    Mon Nov  4 14:20:38 1991
  524. --- new/DOC/part3.tex    Wed Dec 30 13:54:00 1992
  525. ***************
  526. *** 42,47 ****
  527. --- 42,51 ----
  528.     Lets the user indicate an $(x,y)$ position with the mouse.\\
  529.   Counter &
  530.     A different way to let a user step through values.\\
  531. + Fouraxis &
  532. +   Lets the user indicate an $(x,y,z,w)$ direction (unit vector) in 4-space.\\
  533. + Colorwheel &
  534. +   Lets the user select an RGB color value.\\
  535.   \hline
  536.   \multicolumn{2}{|c|}{Input Objects}\\
  537.   \hline
  538. ***************
  539. *** 129,134 ****
  540. --- 133,140 ----
  541.   \input{CLASSES/dial.tex}
  542.   \input{CLASSES/positioner.tex}
  543.   \input{CLASSES/counter.tex}
  544. + \input{CLASSES/fouraxis.tex}
  545. + \input{CLASSES/colorwheel.tex}
  546.   
  547.   \chapter{Input objects}
  548.   
  549. diff -r -c orig/FORMS/INCLUDE/aaa.h new/FORMS/INCLUDE/aaa.h
  550. *** orig/FORMS/INCLUDE/aaa.h    Thu Nov 28 01:56:34 1991
  551. --- new/FORMS/INCLUDE/aaa.h    Wed Jun  9 19:56:12 1993
  552. ***************
  553. *** 182,188 ****
  554.   #define FL_FONT_BOLDNAME    "Helvetica-Bold"
  555.   #define FL_FONT_ITALICNAME    "Helvetica-Oblique"
  556.   #define FL_FONT_FIXEDNAME    "Courier"
  557. ! #define FL_FONT_ICONNAME    "Icon"
  558.   
  559.   #define FL_SMALL_FONT        8.0
  560.   #define FL_NORMAL_FONT        11.0
  561. --- 182,188 ----
  562.   #define FL_FONT_BOLDNAME    "Helvetica-Bold"
  563.   #define FL_FONT_ITALICNAME    "Helvetica-Oblique"
  564.   #define FL_FONT_FIXEDNAME    "Courier"
  565. ! #define FL_FONT_ICONNAME    "Symbol"
  566.   
  567.   #define FL_SMALL_FONT        8.0
  568.   #define FL_NORMAL_FONT        11.0
  569. ***************
  570. *** 326,332 ****
  571.   void    fl_unset_clipping(void);
  572.   
  573.   void    fl_init_fonts();
  574. ! void    fl_set_font(char [], char [], char [], char[]);
  575.   float    fl_get_char_height(float, int);
  576.   float    fl_get_char_width(float, int, char);
  577.   float    fl_get_string_width(float, int, char []);
  578. --- 326,332 ----
  579.   void    fl_unset_clipping(void);
  580.   
  581.   void    fl_init_fonts();
  582. ! void    fl_set_font(char [], char [], char [], char[], char []);
  583.   float    fl_get_char_height(float, int);
  584.   float    fl_get_char_width(float, int, char);
  585.   float    fl_get_string_width(float, int, char []);
  586. Only in new/FORMS/INCLUDE: colorwheel.h
  587. Only in new/FORMS/INCLUDE: fouraxis.h
  588. diff -r -c orig/FORMS/Makefile new/FORMS/Makefile
  589. *** orig/FORMS/Makefile    Wed Nov 27 09:33:55 1991
  590. --- new/FORMS/Makefile    Fri Feb 12 16:29:37 1993
  591. ***************
  592. *** 10,17 ****
  593.   #
  594.   # For instalation. Change this to your settings.
  595.   #
  596. ! INCLUDEDIR= /usr/include
  597. ! LIBDIR= /usr/lib
  598.   #
  599.   #   products
  600.   #
  601. --- 10,17 ----
  602.   #
  603.   # For instalation. Change this to your settings.
  604.   #
  605. ! INCLUDEDIR= /usr/local/include
  606. ! LIBDIR= /usr/local/lib
  607.   #
  608.   #   products
  609.   #
  610. ***************
  611. *** 20,36 ****
  612.   #
  613.   #   compilation control
  614.   #
  615. ! LIBOBJS= ${LIB}(box.o) ${LIB}(text.o) ${LIB}(slider.o) ${LIB}(input.o) \
  616. !          ${LIB}(menu.o) ${LIB}(button.o) ${LIB}(dial.o) ${LIB}(timer.o) \
  617. !          ${LIB}(free.o) ${LIB}(clock.o) ${LIB}(counter.o) \
  618. !          ${LIB}(browser.o) ${LIB}(positioner.o) ${LIB}(goodies.o) \
  619. !      ${LIB}(symbols.o) ${LIB}(draw.o)  ${LIB}(objects.o) ${LIB}(forms.o) \
  620. !      ${LIB}(events.o) ${LIB}(fselect.o) ${LIB}(choice.o) ${LIB}(bitmap.o) \
  621. !      ${LIB}(chart.o) ${LIB}(support.o)
  622.   
  623. ! all:        ${LIBOBJS}
  624.   
  625. ! ${LIBOBJS}:    ${INCLUDE}
  626.   
  627.   .c.a:
  628.       ${CC} -c ${CFLAGS} $<
  629. --- 20,37 ----
  630.   #
  631.   #   compilation control
  632.   #
  633. ! OBJS= box.o text.o slider.o input.o \
  634. !          menu.o button.o dial.o timer.o \
  635. !          free.o clock.o counter.o \
  636. !          browser.o positioner.o goodies.o \
  637. !      symbols.o draw.o  objects.o forms.o \
  638. !      events.o fselect.o choice.o bitmap.o fouraxis.o colorwheel.o \
  639. !      chart.o support.o
  640.   
  641. ! all:        ${LIB}
  642.   
  643. ! ${LIB}:    ${OBJS}
  644. !     ${AR} ${ARFLAGS} $@ ${OBJS}
  645.   
  646.   .c.a:
  647.       ${CC} -c ${CFLAGS} $<
  648. ***************
  649. *** 43,48 ****
  650.   empty:
  651.       -rm -f ${INCLUDE} ${LIB}
  652.   
  653. ! install:    ${LIBOBJS}
  654.       cp ${LIB} ${LIBDIR}
  655.       cp ${INCLUDE} ${INCLUDEDIR}
  656. --- 44,51 ----
  657.   empty:
  658.       -rm -f ${INCLUDE} ${LIB}
  659.   
  660. ! install:    ${LIB}
  661.       cp ${LIB} ${LIBDIR}
  662.       cp ${INCLUDE} ${INCLUDEDIR}
  663. + 
  664. + objs:    ${OBJS}
  665. diff -r -c orig/FORMS/bitmap.c new/FORMS/bitmap.c
  666. *** orig/FORMS/bitmap.c    Mon Nov 18 02:32:06 1991
  667. --- new/FORMS/bitmap.c    Thu Jul 22 23:09:20 1993
  668. ***************
  669. *** 17,31 ****
  670.   char *bits;            /* pointer to the bitmap */
  671.   } SPEC;
  672.   
  673. - static unsigned long thebits[FL_BITMAP_MAXSIZE];
  674. - 
  675.   static void draw_bitmap(FL_OBJECT *ob)
  676.   /* draws the bitmap */
  677.   {
  678.     SPEC *sp = ((SPEC *)(ob->spec));
  679. !   int i,j,c,k = 0;
  680. !   short r,g,b;
  681. !   int xx,yy;        /* position of bitmap */
  682.   
  683.     /* Draw the box */
  684.     fl_drw_box(ob->boxtype,ob->x,ob->y,ob->w,ob->h,ob->col2,FL_BITMAP_BW);
  685. --- 17,31 ----
  686.   char *bits;            /* pointer to the bitmap */
  687.   } SPEC;
  688.   
  689.   static void draw_bitmap(FL_OBJECT *ob)
  690.   /* draws the bitmap */
  691.   {
  692.     SPEC *sp = ((SPEC *)(ob->spec));
  693. !   
  694. !   unsigned int j,k = 0;
  695. !   long color[2];
  696. !   int i, xx,yy;        /* position of bitmap */
  697. !   unsigned long thebits[FL_BITMAP_MAXSIZE];
  698.   
  699.     /* Draw the box */
  700.     fl_drw_box(ob->boxtype,ob->x,ob->y,ob->w,ob->h,ob->col2,FL_BITMAP_BW);
  701. ***************
  702. *** 33,52 ****
  703.                   ob->lcol,ob->lsize,ob->lstyle,ob->label);
  704.   
  705.     if (sp->bits_w == 0) return;
  706.     /* Create the bitmap */
  707.     for (j=0; j<sp->bits_h; j++)
  708.     {
  709. !     for (i=0; i<sp->bits_w; i++)
  710. !     {
  711. !       if (sp->bits[k + i/8] & (1 << (i % 8))) c = ob->col1; else c = ob->col2;
  712. !       if (fl_rgbmode)
  713. !       {
  714. !         fl_getmcolor(c,&r,&g,&b);
  715. !         thebits[(sp->bits_h-j-1)*sp->bits_w+i] = 0x10000 * b + 0x100 * g + r;
  716. !       }
  717. !       else
  718. !         thebits[(sp->bits_h-j-1)*sp->bits_w+i] = (short)c;
  719. !     }
  720.       k += (sp->bits_w+7)/8;
  721.     }
  722.   
  723. --- 33,67 ----
  724.                   ob->lcol,ob->lsize,ob->lstyle,ob->label);
  725.   
  726.     if (sp->bits_w == 0) return;
  727. + 
  728. +   if(fl_rgbmode) {
  729. +     short r,g,b;
  730. +     fl_getmcolor(ob->col1, &r,&g,&b);  color[1] = (b<<16) | (g<<8) | r;
  731. +     fl_getmcolor(ob->col2, &r,&g,&b);  color[0] = (b<<16) | (g<<8) | r;
  732. +   } else {
  733. +     color[1] = ob->col1;
  734. +     color[0] = ob->col2;
  735. +   }
  736. + 
  737.     /* Create the bitmap */
  738.     for (j=0; j<sp->bits_h; j++)
  739.     {
  740. !     register unsigned long *op = &thebits[(sp->bits_h - j - 1) * sp->bits_w];
  741. !     unsigned char *ip = (unsigned char *)&sp->bits[k];
  742. !     i = sp->bits_w;
  743. !     do {
  744. !     register int byte = *ip++;
  745. !     switch(i <= 8 ? (i & 7) : 0) {
  746. !     case 0: *op++ = color[byte&1]; byte >>= 1;
  747. !     case 7: *op++ = color[byte&1]; byte >>= 1;
  748. !     case 6: *op++ = color[byte&1]; byte >>= 1;
  749. !     case 5: *op++ = color[byte&1]; byte >>= 1;
  750. !     case 4: *op++ = color[byte&1]; byte >>= 1;
  751. !     case 3: *op++ = color[byte&1]; byte >>= 1;
  752. !     case 2: *op++ = color[byte&1]; byte >>= 1;
  753. !     case 1: *op++ = color[byte&1]; byte >>= 1;
  754. !     }
  755. !     } while((i -= 8) > 0);
  756.       k += (sp->bits_w+7)/8;
  757.     }
  758.   
  759. diff -r -c orig/FORMS/browser.c new/FORMS/browser.c
  760. *** orig/FORMS/browser.c    Thu Dec 12 05:09:14 1991
  761. --- new/FORMS/browser.c    Tue Jun 22 21:10:34 1993
  762. ***************
  763. *** 153,158 ****
  764. --- 153,159 ----
  765.         case 's': size = FL_SMALL_FONT; break;
  766.         case 'b':    style = FL_BOLD_STYLE; break;
  767.         case 'i':    style = FL_ITALIC_STYLE; break;
  768. +       case 'I': style = FL_ICON_STYLE; break;
  769.         case 'f':    style = FL_FIXED_STYLE; break;
  770.         case 'c':    align = FL_ALIGN_CENTER; break;
  771.         case 'r':    align = FL_ALIGN_RIGHT; break;
  772. Only in new/FORMS: colorwheel.c
  773. diff -r -c orig/FORMS/draw.c new/FORMS/draw.c
  774. *** orig/FORMS/draw.c    Wed Nov 27 09:04:20 1991
  775. --- new/FORMS/draw.c    Wed Oct 20 19:05:49 1993
  776. ***************
  777. *** 17,22 ****
  778. --- 17,23 ----
  779.   #include <gl/device.h>
  780.   #include <fmclient.h>
  781.   #include <string.h>
  782. + #include <sys/utsname.h>    /* 4.0.5 hack */
  783.   #include "forms.h"
  784.   
  785.   /*********
  786. ***************
  787. *** 23,37 ****
  788.      Mouse stuff.
  789.   *********/
  790.   
  791.   void fl_get_mouse(float *xx,float *yy)
  792.   /* returns the position of the mouse in world coordinates*/
  793.   {
  794. !   long x,y;
  795.     getorigin(&x,&y);
  796. !   *xx = (float) (getvaluator(MOUSEX)-x);
  797. !   *yy = (float) (getvaluator(MOUSEY)-y);
  798.   }
  799.   
  800.   /*********
  801.      Clipping.
  802.   *********/
  803. --- 24,67 ----
  804.      Mouse stuff.
  805.   *********/
  806.   
  807. + static struct {
  808. +    long x, y;
  809. +    int valid;
  810. + } mouse;
  811. + 
  812. + /*
  813. +  * Remember, briefly, where the mouse was when a button is clicked;
  814. +  * lets us keep things straight when we're behind real time.
  815. +  */
  816. + void fl_mouse_click_at(long xpix, long ypix)
  817. + {
  818. +   mouse.x = xpix;
  819. +   mouse.y = ypix;
  820. +   mouse.valid = 1;
  821. + }
  822. + 
  823. + void fl_get_raw_mouse(long *xx, long *yy)
  824. + {
  825. +   if(!mouse.valid) {
  826. +     mouse.x = getvaluator(MOUSEX);
  827. +     mouse.y = getvaluator(MOUSEY);
  828. +   }
  829. +   *xx = mouse.x;
  830. +   *yy = mouse.y;
  831. +   mouse.valid = 0;
  832. + }
  833. + 
  834.   void fl_get_mouse(float *xx,float *yy)
  835.   /* returns the position of the mouse in world coordinates*/
  836.   {
  837. !   long x,y, mx,my;
  838. !   fl_get_raw_mouse(&mx, &my);
  839.     getorigin(&x,&y);
  840. !   *xx = mx - x;
  841. !   *yy = my - y;
  842.   }
  843.   
  844. + 
  845.   /*********
  846.      Clipping.
  847.   *********/
  848. ***************
  849. *** 59,93 ****
  850.      Font related stuff
  851.   *********/
  852.   
  853. ! static fmfonthandle thefont[5],smallfont[5],normalfont[5],largefont[5],
  854. !     iconfont;
  855. ! 
  856. ! void fl_set_font(char normalname[], char boldname[],
  857. !         char italicname[], char fixedname[])
  858.   {
  859.     int i;
  860. !   fminit();
  861. !   thefont[0] = fmfindfont(normalname);
  862. !   thefont[1] = fmfindfont(boldname);
  863. !   thefont[2] = fmfindfont(italicname);
  864. !   thefont[3] = fmfindfont(fixedname);
  865. !   for (i=0; i<4; i++)
  866. !   {
  867. !     smallfont[i] = fmscalefont(thefont[i],FL_SMALL_FONT);
  868. !     normalfont[i] = fmscalefont(thefont[i],FL_NORMAL_FONT);
  869. !     largefont[i] = fmscalefont(thefont[i],FL_LARGE_FONT);
  870. !   }
  871. !   thefont[4] = thefont[0];
  872. !   smallfont[4] = smallfont[0];
  873. !   normalfont[4] = normalfont[0];
  874. !   largefont[4] = largefont[0];
  875.   }
  876.   
  877.   void fl_init_fonts()
  878.   {
  879. !   fl_set_font(FL_FONT_NAME,FL_FONT_BOLDNAME,
  880. !             FL_FONT_ITALICNAME,FL_FONT_FIXEDNAME);
  881. !   iconfont = fmfindfont(FL_FONT_ICONNAME);
  882.   }
  883.   
  884.   float fl_get_char_height(float size, int style)
  885. --- 89,166 ----
  886.      Font related stuff
  887.   *********/
  888.   
  889. ! static fmfonthandle thefont[6],smallfont[6],normalfont[6],largefont[6];
  890. ! static char *fontname[6] = {
  891. !     FL_FONT_NAME,        FL_FONT_BOLDNAME,    FL_FONT_ITALICNAME,
  892. !     FL_FONT_FIXEDNAME,    NULL,            FL_FONT_ICONNAME
  893. ! };
  894. ! 
  895. ! static float fontscale = 0;
  896. ! 
  897. ! void fl_set_font(char normal[], char bold[],
  898. !         char italic[], char fixed[],
  899. !         char icon[])
  900.   {
  901.     int i;
  902. !   fontname[FL_NORMAL_STYLE] = normal;
  903. !   fontname[FL_BOLD_STYLE] = bold;
  904. !   fontname[FL_ITALIC_STYLE] = italic;
  905. !   fontname[FL_FIXED_STYLE] = fixed;
  906. !   fontname[FL_ICON_STYLE] = icon;
  907. !    /* Invalidate font cache */
  908. !   bzero(thefont, sizeof(thefont));
  909. !   bzero(smallfont, sizeof(smallfont));
  910. !   bzero(normalfont, sizeof(normalfont));
  911. !   bzero(largefont, sizeof(largefont));
  912.   }
  913.   
  914.   void fl_init_fonts()
  915.   {
  916. !   if(fontscale == 0) {
  917. !     /* Kludge to handle fontmgr "bug" fix in >= 4.0.5:
  918. !      * Fonts are now scaled to appear as constant real size (Postscript style)
  919. !      * as opposed to constant size in pixels (as 3.x and 4.0.[1..4] fmgr did).
  920. !      * FORMS programs (at least fdesign'ed ones) assume constant pixel size,
  921. !      * so if this bugfix was applied, we apply the inverse transformation here.
  922. !      */
  923. !     struct utsname whatami;
  924. !     uname(&whatami);
  925. !     fontscale = 1.0;        /* Old systems work as we expect */
  926. !     if(strcmp(whatami.release, "4.0.5") >= 0)
  927. !     fontscale = ((float)getgdesc(GD_XMMAX)/getgdesc(GD_XPMAX)) / 0.265;
  928. !   }
  929. ! 
  930. !   fminit();
  931. !  /* No need to do this now -- statically initialized.
  932. !   * fl_set_font(FL_FONT_NAME,FL_FONT_BOLDNAME,
  933. !   *            FL_FONT_ITALICNAME,FL_FONT_FIXEDNAME,
  934. !   *            FL_FONT_ICONNAME);
  935. !   */
  936. ! }
  937. ! 
  938. ! fmfonthandle
  939. ! fl_get_font(float size, int style)
  940. ! {
  941. !   fmfonthandle fnt = NULL;
  942. !   fmfonthandle *fp = &fnt;
  943. ! 
  944. !   if (style < 0 || style >= 6)
  945. !     {fl_error("fl_get_font","Unknown font style"); return NULL;}
  946. !   if (size == FL_SMALL_FONT) fp = &smallfont[style];
  947. !   else if (size == FL_NORMAL_FONT) fp = &normalfont[style];
  948. !   else if (size == FL_LARGE_FONT) fp = &largefont[style];
  949. !   if(*fp == NULL) {
  950. !     if(thefont[style] == NULL) {
  951. !     if(style == 0 || style == 4)
  952. !        thefont[0] = thefont[4] = fmfindfont(fontname[0]);
  953. !     else
  954. !        thefont[style] = fmfindfont(fontname[style]);
  955. !     }
  956. !     *fp = fmscalefont(thefont[style], size*fontscale);
  957. !   }
  958. !   if(*fp == NULL)
  959. !     fl_error("fl_get_font", "Unknown font");
  960. !   return *fp;
  961.   }
  962.   
  963.   float fl_get_char_height(float size, int style)
  964. ***************
  965. *** 95,109 ****
  966.   {
  967.     fmfontinfo info;
  968.     fmfonthandle fnt;
  969. !   if (style < 0 || style >= 6)
  970. !     {fl_error("fl_get_char_height","Unknown font style"); return 0.0;}
  971. !   if (style == FL_ICON_STYLE) fnt = iconfont;
  972. !   else if (size == FL_SMALL_FONT) fnt = smallfont[style];
  973. !   else if (size == FL_NORMAL_FONT) fnt = normalfont[style];
  974. !   else if (size == FL_LARGE_FONT) fnt = largefont[style];
  975. !   else  fnt = fmscalefont(thefont[style],size);
  976. !   if (fnt == NULL)
  977. !     {fl_error("fl_get_char_height","Font does not exist."); return 0.0;}
  978.     fmgetfontinfo(fnt,&info);
  979.     return (float) info.height;
  980.   }
  981. --- 168,175 ----
  982.   {
  983.     fmfontinfo info;
  984.     fmfonthandle fnt;
  985. !   if((fnt = fl_get_font(size, style)) == NULL)
  986. !     return 0.0;
  987.     fmgetfontinfo(fnt,&info);
  988.     return (float) info.height;
  989.   }
  990. ***************
  991. *** 113,127 ****
  992.   {
  993.     fmfontinfo info;
  994.     fmfonthandle fnt;
  995. !   if (style < 0 || style >= 6)
  996. !     {fl_error("fl_get_string_width","Unknown font style"); return 0.0;}
  997. !   if (style == FL_ICON_STYLE) fnt = iconfont;
  998. !   else if (size == FL_SMALL_FONT) fnt = smallfont[style];
  999. !   else if (size == FL_NORMAL_FONT) fnt = normalfont[style];
  1000. !   else if (size == FL_LARGE_FONT) fnt = largefont[style];
  1001. !   else  fnt = fmscalefont(thefont[style],size);
  1002. !   if (fnt == NULL)
  1003. !     {fl_error("fl_get_string_width","Font does not exist."); return 0.0;}
  1004.     fmgetfontinfo(fnt,&info);
  1005.     return (float) fmgetstrwidth(fnt,str);
  1006.   }
  1007. --- 179,186 ----
  1008.   {
  1009.     fmfontinfo info;
  1010.     fmfonthandle fnt;
  1011. !   if((fnt = fl_get_font(size, style)) == NULL)
  1012. !     return 0.0;
  1013.     fmgetfontinfo(fnt,&info);
  1014.     return (float) fmgetstrwidth(fnt,str);
  1015.   }
  1016. ***************
  1017. *** 138,173 ****
  1018.      Color Stuff.
  1019.   *********/
  1020.   
  1021. - static short fl_red[4096], fl_green[4096], fl_blue[4096];
  1022.   
  1023.   void fl_init_colormap()
  1024.   {
  1025. !   long cmwin, oldwin;
  1026. !   int i;
  1027. !   /* Read colormap colors into internal table */
  1028. !   oldwin = winget();
  1029. !   noport();
  1030. !   cmwin = winopen("CM");
  1031. !   for (i=0; i<4096; i++)
  1032. !     getmcolor(i,&fl_red[i],&fl_green[i],&fl_blue[i]);
  1033. !   winclose(cmwin);
  1034. !   if (oldwin >= 0) winset(oldwin);
  1035. !   /* Correct colors for small number of bitplanes */
  1036. !   if (getgdesc(GD_BITS_NORM_DBL_RED) <= 4)
  1037. !     for (i=0; i<4096; i++)
  1038. !     {
  1039. !        fl_red[i] = 8 * (fl_red[i] / 8);
  1040. !        fl_green[i] = 8 * (fl_green[i] / 8);
  1041. !        fl_blue[i] = 8 * (fl_blue[i] / 8);
  1042.       }
  1043.   }
  1044.   
  1045.   void fl_color(int col)
  1046.   /* Sets a colormap index in RGB mode. */
  1047.   {
  1048. !   if (fl_rgbmode)
  1049. !     RGBcolor(fl_red[col],fl_green[col],fl_blue[col]);
  1050. !   else
  1051.       color(col);
  1052.   }
  1053.   
  1054. --- 197,243 ----
  1055.      Color Stuff.
  1056.   *********/
  1057.   
  1058.   
  1059. + static long fl_cmap[4096];
  1060. + 
  1061.   void fl_init_colormap()
  1062.   {
  1063. !   bzero(fl_cmap, sizeof(fl_cmap));
  1064. ! }
  1065. ! 
  1066. ! void fl_getmcolor(int index, short *red, short *green, short *blue)
  1067. ! {
  1068. !   long v;
  1069. !   short r,g,b;
  1070. ! 
  1071. !   if(!fl_rgbmode) {
  1072. !     getmcolor(index, red, green, blue);
  1073. !     return;
  1074. !   }
  1075. !   if(index < 0 || index >= 4096)
  1076. !     return;
  1077. !   if((v = fl_cmap[index]) != 0) {
  1078. !     *red = v & 0xFF;
  1079. !     *green = (v>>8) & 0xFF;
  1080. !     *blue = (v>>16) & 0xFF;
  1081. !   } else {
  1082. !     if(winget() <= 0) {
  1083. !     noport();
  1084. !     winopen("CM");
  1085.       }
  1086. +     getmcolor(index, red, green, blue);
  1087. +     fl_mapcolor(index, *red, *green, *blue);
  1088. +   }
  1089.   }
  1090.   
  1091.   void fl_color(int col)
  1092.   /* Sets a colormap index in RGB mode. */
  1093.   {
  1094. !   short r,g,b;
  1095. !   if (fl_rgbmode) {
  1096. !     fl_getmcolor(col, &r,&g,&b);
  1097. !     RGBcolor(r,g,b);
  1098. !   } else
  1099.       color(col);
  1100.   }
  1101.   
  1102. ***************
  1103. *** 174,194 ****
  1104.   void fl_mapcolor(int i, short red, short green, short blue)
  1105.   /* Changes a colormap index */
  1106.   {
  1107. !   if (fl_rgbmode)
  1108. !     { fl_red[i] = red; fl_green[i] = green; fl_blue[i] = blue;}
  1109. !   else
  1110.       mapcolor(i,red,green,blue);
  1111.   }
  1112.   
  1113. - void fl_getmcolor(int i, short *red, short *green, short *blue)
  1114. - /* Returns a colormap index */
  1115. - {
  1116. -   if (fl_rgbmode)
  1117. -     {*red = fl_red[i]; *green = fl_green[i]; *blue = fl_blue[i];}
  1118. -   else
  1119. -     getmcolor(i,red,green,blue);
  1120. - }
  1121. - 
  1122.   /*********
  1123.      Drawing boxes.
  1124.   *********/
  1125. --- 244,257 ----
  1126.   void fl_mapcolor(int i, short red, short green, short blue)
  1127.   /* Changes a colormap index */
  1128.   {
  1129. !   if (fl_rgbmode) {
  1130. !     if(i >= 0 && i < 4096)
  1131. !     fl_cmap[i] = 0xFF000000 | ((blue&0xFF) << 16) |
  1132. !             ((green&0xFF) << 8) | ((red&0xFF));
  1133. !   } else
  1134.       mapcolor(i,red,green,blue);
  1135.   }
  1136.   
  1137.   /*********
  1138.      Drawing boxes.
  1139.   *********/
  1140. ***************
  1141. *** 359,372 ****
  1142.   
  1143.     if (pos!=0 && (str == NULL || str[0] == '\0')) return;
  1144.     /* Set the font correctly. */
  1145. !   if (style < 0 || style >= 6)
  1146. !     {fl_error("fl_drw_text_cursor","Unknown font style"); return;}
  1147. !   if (style == FL_ICON_STYLE) fnt = iconfont;
  1148. !   else if (size == FL_SMALL_FONT) fnt = smallfont[style];
  1149. !   else if (size == FL_NORMAL_FONT) fnt = normalfont[style];
  1150. !   else if (size == FL_LARGE_FONT) fnt = largefont[style];
  1151. !   else  fnt = fmscalefont(thefont[style],size);
  1152. !   if (fnt == NULL)
  1153.       {fl_error("fl_drw_test_cursor","Font does not exist."); return;}
  1154.     fmsetfont(fnt);
  1155.     fmgetfontinfo(fnt,&info);
  1156. --- 422,428 ----
  1157.   
  1158.     if (pos!=0 && (str == NULL || str[0] == '\0')) return;
  1159.     /* Set the font correctly. */
  1160. !   if((fnt = fl_get_font(size, style)) == NULL)
  1161.       {fl_error("fl_drw_test_cursor","Font does not exist."); return;}
  1162.     fmsetfont(fnt);
  1163.     fmgetfontinfo(fnt,&info);
  1164. diff -r -c orig/FORMS/events.c new/FORMS/events.c
  1165. *** orig/FORMS/events.c    Tue Nov 12 06:51:35 1991
  1166. --- new/FORMS/events.c    Thu May 28 17:58:51 1992
  1167. ***************
  1168. *** 46,53 ****
  1169.   
  1170.   #define QSIZE    700
  1171.   
  1172. ! static int queued[MAXSGIDEVICE];    /* devices queued by user */
  1173.   
  1174.   static short thedev[QSIZE];          /* The event queue */
  1175.   static short theval[QSIZE];
  1176.   static int head = 0 , tail = 0;
  1177. --- 46,57 ----
  1178.   
  1179.   #define QSIZE    700
  1180.   
  1181. ! static char queued[(MAXSGIDEVICE+7)/8];    /* devices queued by user */
  1182.   
  1183. + #define    BITSET(cvec, bit)  (cvec)[(bit) >> 3] |= 1 << ((bit)&7)
  1184. + #define BITCLEAR(cvec, bit)  (cvec)[(bit) >> 3] &= ~(1 << ((bit)&7))
  1185. + #define    BITTEST(cvec, bit)  ((cvec)[(bit) >> 3] & 1 << ((bit)&7))
  1186. + 
  1187.   static short thedev[QSIZE];          /* The event queue */
  1188.   static short theval[QSIZE];
  1189.   static int head = 0 , tail = 0;
  1190. ***************
  1191. *** 67,81 ****
  1192.   /* initializes the event setting */
  1193.   {
  1194.     int i;
  1195. !   for (i=0; i<MAXSGIDEVICE; i++) queued[i] = !special_event( (Device) i);
  1196. !   queued[REDRAW] = TRUE;
  1197. !   queued[INPUTCHANGE] = TRUE;
  1198.   }
  1199.   
  1200.   void fl_qdevice(Device dev)
  1201.   /* queues a device */
  1202.   {
  1203. !   queued[dev] = TRUE;
  1204.     qdevice(dev);
  1205.   }
  1206.   
  1207. --- 71,89 ----
  1208.   /* initializes the event setting */
  1209.   {
  1210.     int i;
  1211. !   for (i=0; i<MAXSGIDEVICE; i++)
  1212. !     if(special_event( (Device) i))
  1213. !     BITSET(queued, i);
  1214. !     else
  1215. !     BITCLEAR(queued, i);
  1216. !   BITSET(queued, REDRAW);
  1217. !   BITSET(queued, INPUTCHANGE);
  1218.   }
  1219.   
  1220.   void fl_qdevice(Device dev)
  1221.   /* queues a device */
  1222.   {
  1223. !   BITSET(queued, dev);
  1224.     qdevice(dev);
  1225.   }
  1226.   
  1227. ***************
  1228. *** 82,94 ****
  1229.   void fl_unqdevice(Device dev)
  1230.   /* unqueues a device */
  1231.   {
  1232. !   if (special_event(dev)) queued[dev] = FALSE; else unqdevice(dev);
  1233.   }
  1234.   
  1235.   int fl_isqueued(Device dev)
  1236.   /* test whether a device is queued */
  1237.   {
  1238. !   return (queued[dev] && isqueued(dev));
  1239.   }
  1240.   
  1241.   long fl_qtest()
  1242. --- 90,102 ----
  1243.   void fl_unqdevice(Device dev)
  1244.   /* unqueues a device */
  1245.   {
  1246. !   if (special_event(dev)) BITCLEAR(queued, dev); else unqdevice(dev);
  1247.   }
  1248.   
  1249.   int fl_isqueued(Device dev)
  1250.   /* test whether a device is queued */
  1251.   {
  1252. !   return (BITTEST(queued, dev) && isqueued(dev));
  1253.   }
  1254.   
  1255.   long fl_qtest()
  1256. ***************
  1257. *** 107,113 ****
  1258.   void fl_qenter(short qtype, short val)
  1259.   /* Adds an event to the queue */
  1260.   {
  1261. !   if (special_event( (Device) qtype) && !queued[qtype]) return;
  1262.     new_events++;
  1263.     if (head == tail-1 || (head == QSIZE-1 && tail == 0))
  1264.       tail = (tail+1) % QSIZE;
  1265. --- 115,121 ----
  1266.   void fl_qenter(short qtype, short val)
  1267.   /* Adds an event to the queue */
  1268.   {
  1269. !   if (special_event( (Device) qtype) && !BITTEST(queued,qtype)) return;
  1270.     new_events++;
  1271.     if (head == tail-1 || (head == QSIZE-1 && tail == 0))
  1272.       tail = (tail+1) % QSIZE;
  1273. diff -r -c orig/FORMS/forms.c new/FORMS/forms.c
  1274. *** orig/FORMS/forms.c    Mon Dec 23 05:09:23 1991
  1275. --- new/FORMS/forms.c    Wed Oct 20 19:06:30 1993
  1276. ***************
  1277. *** 149,156 ****
  1278.         {wx = (screenw - (long)(form->w))/2; wy = (screenh - (long)(form->h))/2;}
  1279.       else if (place == FL_PLACE_MOUSE)
  1280.       {
  1281. !       wx = (long) (getvaluator(MOUSEX) - 0.5*form->w);
  1282. !       wy = (long) (getvaluator(MOUSEY) - 0.5*form->h);
  1283.       }
  1284.       else if (place == FL_PLACE_POSITION)
  1285.       {
  1286. --- 149,157 ----
  1287.         {wx = (screenw - (long)(form->w))/2; wy = (screenh - (long)(form->h))/2;}
  1288.       else if (place == FL_PLACE_MOUSE)
  1289.       {
  1290. !       fl_get_raw_mouse(&wx, &wy);
  1291. !       wx -= form->w / 2;
  1292. !       wy -= form->h / 2;
  1293.       }
  1294.       else if (place == FL_PLACE_POSITION)
  1295.       {
  1296. ***************
  1297. *** 177,182 ****
  1298. --- 178,186 ----
  1299.     qdevice(LEFTARROWKEY); qdevice(RIGHTARROWKEY);
  1300.     qdevice(UPARROWKEY); qdevice(DOWNARROWKEY);
  1301.     qdevice(WINQUIT);
  1302. +   tie(MOUSE1, MOUSEX, MOUSEY);
  1303. +   tie(MOUSE2, MOUSEX, MOUSEY);
  1304. +   tie(MOUSE3, MOUSEX, MOUSEY);
  1305.     reshape_form(form);
  1306.     fl_redraw_form(form);
  1307.     /* Check whether the window appear under the mouse and generate an
  1308. ***************
  1309. *** 184,190 ****
  1310.     */
  1311.     getorigin(&x,&y);
  1312.     getsize(&w,&h);
  1313. !   mx = getvaluator(MOUSEX); my = getvaluator(MOUSEY);
  1314.     if (mx>=x && mx<=x+w && my>=y && my<=y+h)
  1315.       qenter(INPUTCHANGE, (short) form->window);
  1316.     if (oldwin > 0 ) winset(oldwin);
  1317. --- 188,194 ----
  1318.     */
  1319.     getorigin(&x,&y);
  1320.     getsize(&w,&h);
  1321. !   fl_get_raw_mouse(&mx, &my);
  1322.     if (mx>=x && mx<=x+w && my>=y && my<=y+h)
  1323.       qenter(INPUTCHANGE, (short) form->window);
  1324.     if (oldwin > 0 ) winset(oldwin);
  1325. ***************
  1326. *** 226,232 ****
  1327.     winset(form->window);
  1328.     getorigin(&x,&y);
  1329.     getsize(&w,&h);
  1330. !   mx = getvaluator(MOUSEX); my = getvaluator(MOUSEY);
  1331.     if (mx>=x && mx<=x+w && my>=y && my<=y+h)
  1332.       qenter(INPUTCHANGE, 0);
  1333.   
  1334. --- 230,236 ----
  1335.     winset(form->window);
  1336.     getorigin(&x,&y);
  1337.     getsize(&w,&h);
  1338. !   fl_get_raw_mouse(&mx, &my);
  1339.     if (mx>=x && mx<=x+w && my>=y && my<=y+h)
  1340.       qenter(INPUTCHANGE, 0);
  1341.   
  1342. ***************
  1343. *** 432,437 ****
  1344. --- 436,452 ----
  1345.       case MOUSE1:
  1346.       case MOUSE2:
  1347.       case MOUSE3:
  1348. +     /* If mouse position is tie()d to mouse button, take advantage of that! */
  1349. +     if(qtest() == MOUSEX) {
  1350. +         short mx, my;
  1351. +         qread(&mx);
  1352. +         fl_qenter(MOUSEX, mx);
  1353. +         if(qtest() == MOUSEY) {
  1354. +         qread(&my);
  1355. +         fl_qenter(MOUSEY, my);
  1356. +         fl_mouse_click_at(mx, my);
  1357. +         }
  1358. +     }
  1359.       if (val)
  1360.       {
  1361.         if (getbutton(LEFTCTRLKEY) && getbutton(LEFTSHIFTKEY) &&
  1362. ***************
  1363. *** 461,467 ****
  1364.     gives strange effects. To avoid this we only treat an
  1365.     enter event if the previous one was a leave event.
  1366.   ************************/
  1367. !       if (lastinputchange != 0) break;
  1368.             lastinputchange = val;
  1369.   
  1370.         if (mouseform != NULL)
  1371. --- 476,488 ----
  1372.     gives strange effects. To avoid this we only treat an
  1373.     enter event if the previous one was a leave event.
  1374.   ************************/
  1375. !     /* No, don't do that.  It's quite possible to get a new window-enter
  1376. !      * event without a preceding window-leave -- when one window pops up
  1377. !      * over another one, which is common for popups!
  1378. !      * The commented-out code below causes FORMS to hose its input focus.
  1379. !      * -slevy 92.04.20
  1380. !      */
  1381. !       /* if (lastinputchange != 0) break; */
  1382.             lastinputchange = val;
  1383.   
  1384.         if (mouseform != NULL)
  1385. Only in new/FORMS: forms.h
  1386. Only in new/FORMS: fouraxis.c
  1387. diff -r -c orig/FORMS/objects.c new/FORMS/objects.c
  1388. *** orig/FORMS/objects.c    Thu Nov 28 08:12:45 1991
  1389. --- new/FORMS/objects.c    Wed Jul 21 19:54:57 1993
  1390. ***************
  1391. *** 383,389 ****
  1392.     if (obj == NULL)
  1393.       { fl_error("fl_redraw_object","Trying to draw NULL object."); return;}
  1394.     if (obj->form == NULL) return;
  1395. !   if (obj->frozen || obj->form->frozen || ! obj->form->visible) return;
  1396.     winset(obj->form->window);
  1397.     if (obj->objclass == FL_BEGIN_GROUP)
  1398.     {
  1399. --- 383,398 ----
  1400.     if (obj == NULL)
  1401.       { fl_error("fl_redraw_object","Trying to draw NULL object."); return;}
  1402.     if (obj->form == NULL) return;
  1403. !   if (obj->frozen) {
  1404. !     obj->frozen = -1;
  1405. !     return;
  1406. !   }
  1407. !   if(obj->form->frozen) {
  1408. !     obj->form->frozen = -1;
  1409. !     return;
  1410. !   }
  1411. !   if(! obj->form->visible)
  1412. !     return;
  1413.     winset(obj->form->window);
  1414.     if (obj->objclass == FL_BEGIN_GROUP)
  1415.     {
  1416. ***************
  1417. *** 415,421 ****
  1418.     long oldwin = winget();
  1419.     if (form == NULL)
  1420.       { fl_error("fl_redraw_form","Drawing NULL form."); return;}
  1421. !   if (form->frozen || ! form->visible) return;
  1422.     winset(form->window);
  1423.     ob = form->first;
  1424.     while ( ob  != NULL )
  1425. --- 424,434 ----
  1426.     long oldwin = winget();
  1427.     if (form == NULL)
  1428.       { fl_error("fl_redraw_form","Drawing NULL form."); return;}
  1429. !   if (form->frozen) {
  1430. !     form->frozen = -1;
  1431. !     return;
  1432. !   }
  1433. !   if (! form->visible) return;
  1434.     winset(form->window);
  1435.     ob = form->first;
  1436.     while ( ob  != NULL )
  1437. ***************
  1438. *** 440,448 ****
  1439.     {
  1440.       ob = obj;
  1441.       while ( (ob = ob->next) != NULL && ob->objclass != FL_END_GROUP )
  1442. !       ob->frozen = 1;
  1443.     }
  1444. !   obj->frozen = 1;
  1445.   }
  1446.   
  1447.   void fl_unfreeze_object(FL_OBJECT *obj)
  1448. --- 453,461 ----
  1449.     {
  1450.       ob = obj;
  1451.       while ( (ob = ob->next) != NULL && ob->objclass != FL_END_GROUP )
  1452. !       ob->frozen |= 1;
  1453.     }
  1454. !   obj->frozen |= 1;
  1455.   }
  1456.   
  1457.   void fl_unfreeze_object(FL_OBJECT *obj)
  1458. ***************
  1459. *** 449,464 ****
  1460.   /* Enable drawing of object */
  1461.   {
  1462.     FL_OBJECT *ob;
  1463.     if (obj == NULL)
  1464.       { fl_error("fl_freeze_object","Unfreezing NULL object."); return;}
  1465.     if (obj->objclass == FL_BEGIN_GROUP)
  1466.     {
  1467.       ob = obj;
  1468. !     while ( (ob = ob->next) != NULL && ob->objclass != FL_END_GROUP )
  1469.         ob->frozen = 0;
  1470.     }
  1471.     obj->frozen = 0;
  1472. !   fl_redraw_object(obj);
  1473.   }
  1474.   
  1475.   void fl_freeze_form(FL_FORM *form)
  1476. --- 462,482 ----
  1477.   /* Enable drawing of object */
  1478.   {
  1479.     FL_OBJECT *ob;
  1480. +   int touched = 0;
  1481.     if (obj == NULL)
  1482.       { fl_error("fl_freeze_object","Unfreezing NULL object."); return;}
  1483.     if (obj->objclass == FL_BEGIN_GROUP)
  1484.     {
  1485.       ob = obj;
  1486. !     while ( (ob = ob->next) != NULL && ob->objclass != FL_END_GROUP ) {
  1487. !       touched |= ob->frozen;
  1488.         ob->frozen = 0;
  1489. +     }
  1490.     }
  1491. +   touched |= obj->frozen;
  1492.     obj->frozen = 0;
  1493. !   if(touched < 0)
  1494. !     fl_redraw_object(obj);
  1495.   }
  1496.   
  1497.   void fl_freeze_form(FL_FORM *form)
  1498. ***************
  1499. *** 466,481 ****
  1500.   {
  1501.     if (form == NULL)
  1502.       { fl_error("fl_freeze_form","Freezing NULL form."); return;}
  1503. !   form->frozen = 1;
  1504.   }
  1505.   
  1506.   void fl_unfreeze_form(FL_FORM *form)
  1507.   /* Enable drawing of form */
  1508.   {
  1509.     if (form == NULL)
  1510.       { fl_error("fl_unfreeze_form","Unfreezing NULL form."); return;}
  1511.     form->frozen = 0;
  1512. !   fl_redraw_form(form);
  1513.   }
  1514.   
  1515.   /*-----------------------------------------------------------------------
  1516. --- 484,501 ----
  1517.   {
  1518.     if (form == NULL)
  1519.       { fl_error("fl_freeze_form","Freezing NULL form."); return;}
  1520. !   form->frozen |= 1;
  1521.   }
  1522.   
  1523.   void fl_unfreeze_form(FL_FORM *form)
  1524.   /* Enable drawing of form */
  1525.   {
  1526. +   int touched;
  1527.     if (form == NULL)
  1528.       { fl_error("fl_unfreeze_form","Unfreezing NULL form."); return;}
  1529. +   touched = form->frozen;
  1530.     form->frozen = 0;
  1531. !   if(touched < 0) fl_redraw_form(form);
  1532.   }
  1533.   
  1534.   /*-----------------------------------------------------------------------
  1535. diff -r -c orig/FORMS/support.c new/FORMS/support.c
  1536. *** orig/FORMS/support.c    Mon Nov 11 13:46:10 1991
  1537. --- new/FORMS/support.c    Wed Oct 20 18:52:34 1993
  1538. ***************
  1539. *** 30,35 ****
  1540. --- 30,39 ----
  1541.   {
  1542.     if (initialized) return;
  1543.     initialized = TRUE;
  1544. +   if(winget() <= 0) {
  1545. +       noport();
  1546. +       winopen("");
  1547. +   }
  1548.     /* Set the graphics mode based on the machine type */
  1549.     if (getgdesc(GD_BITS_NORM_SNG_RED) == 0) /* no rgbmode possible */
  1550.       { fl_doublebuf = FALSE; fl_rgbmode = FALSE;}
  1551.  
  1552.    ... create new file demof01.c ...
  1553. *** /dev/null    Wed Oct 20 19:15:53 1993
  1554. --- new/DEMOS/demof01.c    Mon Aug 10 19:21:28 1992
  1555. ***************
  1556. *** 0 ****
  1557. --- 1,62 ----
  1558. + #include "forms.h"
  1559. + 
  1560. + FL_OBJECT *axis, *text, *quit;
  1561. + 
  1562. + void
  1563. + Quit(FL_OBJECT *obj, long val)
  1564. + {
  1565. +     exit(0);
  1566. + }
  1567. + 
  1568. + void
  1569. + TextIn(FL_OBJECT *obj, long val)
  1570. + {
  1571. +     float x,y,z,w;
  1572. + 
  1573. +     if(sscanf(fl_get_input(obj), "%f %f %f", &x,&y,&z) == 3)
  1574. +     fl_set_fouraxis(axis, x,y,z);
  1575. +     sync_input();
  1576. + }
  1577. + 
  1578. + void
  1579. + AxisIn(FL_OBJECT *obj, long val)
  1580. + {
  1581. +     sync_input();
  1582. + }
  1583. + 
  1584. + sync_input()
  1585. + {
  1586. +     char stuff[80];
  1587. +     float x,y,z,w;
  1588. + 
  1589. +     fl_get_fouraxis(axis, &x,&y,&z,&w);
  1590. +     sprintf(stuff, "%.4f %.4f %.4f %.4f", x,y,z,w);
  1591. +     fl_set_input(text, stuff);
  1592. + }
  1593. + 
  1594. + main(argc, argv)
  1595. +   char *argv[];
  1596. + {
  1597. +   FL_FORM *mine;
  1598. +   FL_OBJECT *obj;
  1599. + 
  1600. +   fl_init();
  1601. + 
  1602. +   mine = fl_bgn_form(FL_NO_BOX,250.0,250.0);
  1603. +   obj = fl_add_box(FL_UP_BOX,0.0,0.0,280.0,340.0,"");
  1604. +   axis = obj = fl_add_fouraxis(argc>1?atoi(argv[1]):FL_NORMAL_FOURAXIS,10.0,40.0,160.0,160.0,"4D axis");
  1605. +     fl_set_call_back(obj,AxisIn,0);
  1606. +   quit = obj = fl_add_button(FL_NORMAL_BUTTON,180.0,20.0,60.0,60.0,"Quit");
  1607. +     fl_set_call_back(obj,Quit,0);
  1608. +   text = obj = fl_add_input(FL_NORMAL_INPUT,10.0,210.0,230.0,30.0,"");
  1609. +     fl_set_object_color(obj,9,9);
  1610. +     fl_set_object_lstyle(obj,FL_BOLD_STYLE);
  1611. +     fl_set_call_back(obj,TextIn,3);
  1612. +   fl_end_form();
  1613. + 
  1614. +   fl_show_form(mine, FL_PLACE_SIZE, 1, "Axis");
  1615. +   sync_input();
  1616. +   while(fl_do_forms())
  1617. +     ;
  1618. +   exit(0);
  1619. + }
  1620.  
  1621.    ... create new file demof02.c ...
  1622. *** /dev/null    Wed Oct 20 19:15:53 1993
  1623. --- new/DEMOS/demof02.c    Mon Aug 10 19:00:04 1992
  1624. ***************
  1625. *** 0 ****
  1626. --- 1,84 ----
  1627. + #include "forms.h"
  1628. + 
  1629. + FL_OBJECT *axis, *text[4], *quit;
  1630. + 
  1631. + void
  1632. + Quit(FL_OBJECT *obj, long val)
  1633. + {
  1634. +     exit(0);
  1635. + }
  1636. + 
  1637. + void
  1638. + TextIn(FL_OBJECT *obj, long val)
  1639. + {
  1640. +     float b[4][4];
  1641. + 
  1642. +     fl_get_fouraxis_basis(axis, &b[0][0]);
  1643. +     if(sscanf(fl_get_input(obj), "%f %f %f %f",
  1644. +             &b[0][val], &b[1][val], &b[2][val], &b[3][val]) == 4) {
  1645. +     fl_set_fouraxis_basis(axis, &b[0][0]);
  1646. +     sync_inputs();
  1647. +     }
  1648. + }
  1649. + 
  1650. + void
  1651. + AxisIn(FL_OBJECT *obj, long val)
  1652. + {
  1653. +     sync_inputs();
  1654. + }
  1655. + 
  1656. + sync_inputs()
  1657. + {
  1658. +     char stuff[80];
  1659. +     float basis[4][4];
  1660. +     int i;
  1661. + 
  1662. +     fl_get_fouraxis_basis(axis, &basis[0][0]);
  1663. +     for(i = 0; i < 4; i++) {
  1664. +     sprintf(stuff, "%7.3f %7.3f %7.3f %7.3f",
  1665. +         basis[0][i], basis[1][i], basis[2][i], basis[3][i]);
  1666. +     fl_set_input(text[i], stuff);
  1667. +     }
  1668. + }
  1669. + 
  1670. + main()
  1671. + {
  1672. +   FL_FORM *mine;
  1673. +   FL_OBJECT *obj;
  1674. + 
  1675. +   fl_init();
  1676. + 
  1677. + 
  1678. +   mine = fl_bgn_form(FL_NO_BOX,280.0,340.0);
  1679. +   obj = fl_add_box(FL_UP_BOX,0.0,0.0,280.0,340.0,"");
  1680. +   axis = obj = fl_add_fouraxis(FL_NORMAL_FOURAXIS,10.0,40.0,160.0,160.0,"4D axis");
  1681. +     fl_set_call_back(obj,AxisIn,0);
  1682. +   text[0] = obj = fl_add_input(FL_NORMAL_INPUT,30.0,300.0,240.0,30.0,"x'");
  1683. +     fl_set_object_color(obj,11,11);
  1684. +     fl_set_object_lstyle(obj,FL_BOLD_STYLE);
  1685. +     fl_set_call_back(obj,TextIn,0);
  1686. +   quit = obj = fl_add_button(FL_NORMAL_BUTTON,200.0,20.0,60.0,60.0,"Quit");
  1687. +     fl_set_call_back(obj,Quit,0);
  1688. +   text[1] = obj = fl_add_input(FL_NORMAL_INPUT,30.0,270.0,240.0,30.0,"y'");
  1689. +     fl_set_object_color(obj,11,11);
  1690. +     fl_set_object_lstyle(obj,FL_BOLD_STYLE);
  1691. +     fl_set_call_back(obj,TextIn,1);
  1692. +   text[2] = obj = fl_add_input(FL_NORMAL_INPUT,30.0,240.0,240.0,30.0,"z'");
  1693. +     fl_set_object_color(obj,11,11);
  1694. +     fl_set_object_lstyle(obj,FL_BOLD_STYLE);
  1695. +     fl_set_call_back(obj,TextIn,2);
  1696. +   text[3] = obj = fl_add_input(FL_NORMAL_INPUT,30.0,210.0,240.0,30.0,"w'");
  1697. +     fl_set_object_color(obj,9,9);
  1698. +     fl_set_object_lstyle(obj,FL_BOLD_STYLE);
  1699. +     fl_set_call_back(obj,TextIn,3);
  1700. +   obj = fl_add_text(FL_NORMAL_TEXT,180.0,150.0,90.0,50.0,"w' is the\nchosen \n4D vector");
  1701. +   obj = fl_add_box(FL_BORDER_BOX,178.0,146.0,90.0,1.0,"");
  1702. +   obj = fl_add_text(FL_NORMAL_TEXT,181.0,88.0,85.0,52.0,"x' y' z' are\northogonal\nto it.");
  1703. +   fl_end_form();
  1704. + 
  1705. +   fl_show_form(mine, FL_PLACE_SIZE, 1, "Axis");
  1706. +   sync_inputs();
  1707. +   while(fl_do_forms())
  1708. +     ;
  1709. +   exit(0);
  1710. + }
  1711.  
  1712.    ... create new file formsstubs.c ...
  1713. *** /dev/null    Wed Oct 20 19:15:53 1993
  1714. --- new/DESIGN/formsstubs.c    Tue Jan 12 21:17:17 1993
  1715. ***************
  1716. *** 0 ****
  1717. --- 1,156 ----
  1718. + /*
  1719. +  * Graphics stub routines.
  1720. +  * Includes minimal mg, GL and forms stubs, sufficient to link the viewer
  1721. +  * without -lforms[2] and without -lgl_s, as of 1/11/92.
  1722. +  */
  1723. + 
  1724. + #include <stdio.h>
  1725. + #include <fmclient.h>
  1726. + 
  1727. + 
  1728. +     /* GL stubs */
  1729. + deflinestyle() { ; }
  1730. + setlinestyle() { ; }
  1731. + pushattributes() { ; }
  1732. + popattributes() { ; }
  1733. + rot() { ; }
  1734. + move() { ; }
  1735. + draw() { ; }
  1736. + viewport() { ; }
  1737. + perspective() { ; }
  1738. + linewidth() { ; }
  1739. + blendfunction() { ; }
  1740. + c4f() { ; }
  1741. + RGBcolor() { ; }
  1742. + RGBmode() { ; }
  1743. + bgnclosedline() { ; }
  1744. + bgnline() { ; }
  1745. + bgnpolygon() { ; }
  1746. + circ() { ; }
  1747. + circf() { ; }
  1748. + cmov2() { ; }
  1749. + cmov2i() { ; }
  1750. + color() { ; }
  1751. + doublebuffer() { ; }
  1752. + endclosedline() { ; }
  1753. + endline() { ; }
  1754. + endpolygon() { ; }
  1755. + gconfig() { ; }
  1756. + getbutton() { return 0; }
  1757. + getcpos() { ; }
  1758. + getmatrix(float T[4][4]) { memset(T, 0, 16*sizeof(float)); T[0][0] = T[1][1] = T[2][2] = T[3][3] = 1.0; }
  1759. + getmcolor(int i, short *r, short *g, short *b) {
  1760. +     *r = i&1 ? 255:0;
  1761. +     *g = i&2 ? 255:0;
  1762. +     *b = i&4 ? 255:0;
  1763. + }
  1764. + getmmode() { return 2 /*MVIEWING*/; }
  1765. + getorigin(long *x0, long *y0) { *x0 = *y0 = 0; }
  1766. + getscrmask(long *x0, long *x1, long *y0, long *y1) { *x0 = *y0 = 0; *x1 = *y1 = 512; }
  1767. + getsize(long *xsize, long *ysize) { *xsize = *ysize = 512; }
  1768. + getvaluator() { static int v = 120; v++; v %= 512; return v; }
  1769. + getviewport(short *x0, short *x1, short *y0, short *y1) { getscrmask(x0,x1,y0,y1); }
  1770. + gl_beginstring() { ; }
  1771. + gl_drawbitmap() { ; }
  1772. + gl_endstring() { ; }
  1773. + isqueued() { return 0; }
  1774. + keepaspect() { ; }
  1775. + loadmatrix() { ; }
  1776. + lrectwrite() { ; }
  1777. + mapcolor() { ; }
  1778. + mmode() { ; }
  1779. + noborder() { ; }
  1780. + noport() { ; }
  1781. + ortho2() { ; }
  1782. + popmatrix() { ; }
  1783. + popviewport() { ; }
  1784. + prefposition() { ; }
  1785. + prefsize() { ; }
  1786. + pushmatrix() { ; }
  1787. + pushviewport() { ; }
  1788. + qdevice() { ; }
  1789. + qenter() { ; }
  1790. + qgetfd() { return 2; }
  1791. + qread() {int c; printf("qread -- <CR> to continue: "); while((c=getchar()) > 0 && c != '\n') ; return 0; }
  1792. + qtest() { return 0; }
  1793. + rect() { ; }
  1794. + rectf() { ; }
  1795. + reshapeviewport() { ; }
  1796. + ringbell() { write(2, "\7", 1); }
  1797. + rotate() { ; }
  1798. + scale() { ; }
  1799. + screenspace() { ; }
  1800. + scrmask() { ; }
  1801. + swapbuffers() { ; }
  1802. + tie() { ; }
  1803. + translate() { ; }
  1804. + unqdevice() { ; }
  1805. + v2f() { ; }
  1806. + winclose() { ; }
  1807. + static int winno = 128;
  1808. + winget() { return winno; }
  1809. + winopen() { return ++winno; }
  1810. + winpop() { ; }
  1811. + winset() { ; }
  1812. + 
  1813. + getgdesc(code) {
  1814. +     switch(code) {
  1815. + 
  1816. + #define GD_XPMAX        0
  1817. + #define GD_YPMAX        1
  1818. + #define GD_XMMAX        2
  1819. + #define GD_YMMAX        3
  1820. + #define GD_ZMIN            4
  1821. + #define GD_ZMAX            5
  1822. + #define GD_BITS_NORM_SNG_RED    6
  1823. + #define GD_BITS_NORM_DBL_RED    9
  1824. + #define GD_BITS_NORM_SNG_CMODE    12
  1825. + #define GD_BITS_NORM_DBL_CMODE    13
  1826. + #define GD_BITS_NORM_SNG_MMAP    14
  1827. + #define GD_BITS_NORM_DBL_MMAP    15
  1828. + #define GD_BITS_NORM_ZBUFFER    16
  1829. + 
  1830. +     case GD_BITS_NORM_DBL_RED:
  1831. +     case GD_BITS_NORM_SNG_RED: return 8;
  1832. +     case GD_XPMAX: return 1280;
  1833. +     case GD_YPMAX: return 1024;
  1834. +     case GD_XMMAX: return 450;
  1835. +     default: printf("getgdesc(%d)?\n", code); return -1;
  1836. +     }
  1837. + }
  1838. + 
  1839. + static long unfont;
  1840. + 
  1841. + drawmode() { ; }
  1842. + mapw2() { ; }
  1843. + clear() { ; }
  1844. + fmfonthandle fmfindfont(char *name) { return &unfont; }
  1845. + fmgetfontinfo(fmfonthandle fnt, fmfontinfo *info) {
  1846. +     bzero(info, sizeof(*info));
  1847. +     info->xsize = info->ysize = info->width = info->height = 10;
  1848. +     info->resolution = 100;
  1849. + }
  1850. + fmgetstrwidth(fmfonthandle fnt, char *str) { return strlen(str)*8; }
  1851. + fmprstr() { ; }
  1852. + fmfonthandle fmscalefont(fmfontinfo *font, double v) { return &unfont; }
  1853. + void fmsetfont(fmfontinfo *font) { ; }
  1854. + fminit() { ; }
  1855. + arc() { ; }
  1856. + arcf() { ; }
  1857. + pnt() { ; }
  1858. + polf2() { ; }
  1859. + poly2() { ; }
  1860. + draw2() { ; }
  1861. + move2() { ; }
  1862. + pclos() { ; }
  1863. + pdr2() { ; }
  1864. + pmv2() { ; }
  1865. + addtopup() { ; }
  1866. + dopup() { ; }
  1867. + freepup() { ; }
  1868. + newpup() { ; }
  1869. + 
  1870. + fl_show_message(char *s1, char *s2, char *s3)
  1871. + {
  1872. +     fprintf(stderr, "%s %s %s\n", s1, s2, s3);
  1873. + }
  1874.  
  1875.    ... create new file colorwheel.tex ...
  1876. *** /dev/null    Wed Oct 20 19:15:53 1993
  1877. --- new/DOC/CLASSES/colorwheel.tex    Wed Dec 30 14:43:50 1992
  1878. ***************
  1879. *** 0 ****
  1880. --- 1,99 ----
  1881. + \section{Colorwheel}
  1882. + 
  1883. + \subsection*{Short Description}
  1884. + 
  1885. + A colorwheel object allows the selction of colors by moving a point
  1886. + around a hexagon using the HSV color scheme.  The value of the
  1887. + colorwheel is set and returned as an RGBA value.
  1888. + 
  1889. + \subsection*{Adding an object}
  1890. + 
  1891. + A colorwheel can be added to a form using the call 
  1892. + 
  1893. + \begin{verbatim}
  1894. +    FL_OBJECT *fl_add_colorwheel(int type, float x, float y, 
  1895. +                             float w, float h, char label[])
  1896. + \end{verbatim}
  1897. + 
  1898. + The meaning of the parameters is as usual.  The label by default is
  1899. + placed below the box.
  1900. + 
  1901. + \subsection*{Types}
  1902. + 
  1903. + There is only one type of colorwheel at this time:  FL\_NORMAL\_COLORWHEEL.
  1904. + 
  1905. + \subsection*{Interaction}
  1906. + 
  1907. + The display shows a Gouraud-shaded hexagon with a black cursor in the
  1908. + middle.  The cursor may be moved around inside the hexagon by clicking
  1909. + or dragging the mouse.  The color under the cursor is the color which
  1910. + will be returned by fl\_get\_colorwheel().  
  1911. + 
  1912. + There is no way for the user to set the intensity of the color using
  1913. + only the colorwheel.  HSV colorspace is actually a solid
  1914. + three-dimensional hexagonal pyramid.  Only a cross-section of the
  1915. + pyramid is shown in the hexagon at any time (For more details, see
  1916. + $\underline{Computer Graphics: Principles and Practice}$ by Foley,
  1917. + vanDam, Feiner, and Hughes).  The intensity may be set
  1918. + programmatically using fl\_set\_colorwheel\_intensity().  In general, the
  1919. + programmer will want to create a slider for this purpose and use
  1920. + fl\_set\_colorwheel\_intensity() to set the intensity of the colorwheel
  1921. + every time the value of the slider is changed.  The colors of the
  1922. + colorwheel will change to reflect the new intensity.  When the
  1923. + colorwheel is created, the intensity is set to 1.0, its maximum value.
  1924. + The colors become darker as the intensity is lowered toward 0.0, at
  1925. + which point the entire colorwheel will be black.
  1926. + 
  1927. + There is also no way for the user of the colorwheel to set the alpha
  1928. + (transparency) value of the color.  Again, the programmer may want to
  1929. + create a slider for this parameter.  On computer systems which support
  1930. + transparency, the colorwheel will fade in and out as the alpha value
  1931. + is changed.  Alpha starts set to 1.0, or fully opaque.  A value of 0.0
  1932. + is equivalent to complete transparency.  The alpha value may be
  1933. + changed using the routine fl\_set\_colorwheel\_alpha().
  1934. + 
  1935. + \subsection*{Other routines}
  1936. + 
  1937. + To set the value of the colorwheel, use the routines:
  1938. + 
  1939. + \begin{verbatim}
  1940. +   void fl_set_colorwheel(FL_OBJECT *obj, float *color)
  1941. + 
  1942. +   void fl_set_colorwheel_intensity(FL_OBJECT *obj, float intensity)
  1943. + 
  1944. +   void fl_set_colorwheel_alpha(FL_OBJECT *obj, float alpha)
  1945. + \end{verbatim}
  1946. + 
  1947. + fl\_set\_colorwheel() sets the colorwheel to the rgb value specified in
  1948. + the color array.  Each component ranges between 0.0 and 1.0.  This
  1949. + routine may also change the intensity.
  1950. + 
  1951. + fl\_set\_colorwheel\_intensity() sets the intensity to a value between
  1952. + 0.0 and 1.0.
  1953. + 
  1954. + fl\_set\_colorwheel\_alpha() sets the transparency to a value between 0.0
  1955. + and 1.0.
  1956. + 
  1957. + To get the value of the colorwheel, use the routines:
  1958. + 
  1959. + \begin{verbatim}
  1960. +   void fl_get_colorwheel(FL_OBJECT *obj, float *color)
  1961. + 
  1962. +   float fl_get_colorhweel_intensity(FL_OBJECT *obj)
  1963. + 
  1964. +   float fl_get_colorwheel_alpha(FL_OBJECT *obj)
  1965. + \end{verbatim}
  1966. + 
  1967. + The values are as described above.  Note that the value returned by
  1968. + fl\_get\_colorwheel() takes the current intensity into account.
  1969. + 
  1970. + \subsection*{Attributes}
  1971. + 
  1972. + Color1 controls the color of the background (default gray).
  1973. + Color2 controls the color of the cursor (default black).
  1974. + 
  1975. + \subsection*{Remarks}
  1976. + 
  1977. + Since the colorwheel uses Gouraud shading and transparency, the form
  1978. + must be in RGB mode (the default).  For best results, it should also
  1979. + be double-buffered (also the default).
  1980.  
  1981.     ... create new file fouraxis.tex ...
  1982. *** /dev/null    Wed Oct 20 19:15:53 1993
  1983. --- new/DOC/CLASSES/fouraxis.tex    Mon Aug 10 19:04:32 1992
  1984. ***************
  1985. *** 0 ****
  1986. --- 1,167 ----
  1987. + % For each class, a file like this should exist
  1988. + % It should also be added in class.tex
  1989. + 
  1990. + \section{Fouraxis}
  1991. + 
  1992. + \subsubsection*{Short description}
  1993. + 
  1994. + A fouraxis allows the user to graphically specify a direction
  1995. + in a four-dimensional space:
  1996. + specifically a unit vector, where $x^2 + y^2 + z^2 + w^2 = 1$.
  1997. + 
  1998. + It displays a wireframe sphere containing a set of movable axes,
  1999. + whose intersection indicates the $(x,y,z)$ components of the 4-vector.
  2000. + The $w$ component is computed from these.
  2001. + 
  2002. + The object can return either the 4-vector itself, or a complete
  2003. + 4x4 orthonormal basis matrix with the specified vector as one of its columns.
  2004. + 
  2005. + \subsubsection*{Adding an object}
  2006. + 
  2007. + A fouraxis can be added to a form using the call
  2008. + 
  2009. + \begin{verbatim}
  2010. +    FL_OBJECT *fl_add_fouraxis(int type, float x, float y,
  2011. +                                 float w, float h, char label[])
  2012. + \end{verbatim}
  2013. + 
  2014. + The meaning of the parameters is as usual. The label by default is
  2015. + placed below the box.
  2016. + 
  2017. + \subsubsection*{Types}
  2018. + 
  2019. + Only one useful type of fouraxis exists at the moment:
  2020. + 
  2021. + \verb+FL_NORMAL_FOURAXIS+, showing three orthogonal axes.
  2022. + 
  2023. + \subsubsection*{Interaction}
  2024. + 
  2025. + The display shows a wireframe sphere and three orthogonal lines:
  2026. + a red vector extending from the origin to the $(x,y,z)$ component of the
  2027. + chosen point, and two other vectors reaching from the $(x,y,z)$ point
  2028. + to the surface of the unit sphere as a perspective aid.
  2029. + 
  2030. + In the wireframe sphere, $x$ increases rightward, $y$ away from the viewer,
  2031. + and $z$ upward.
  2032. + 
  2033. + The left mouse button rotates the chosen $(x,y,z)$ point within the sphere,
  2034. + keeping its radial component constant.  Horizontal motion rotates
  2035. + in longitude (the $x-y$ plane), while vertical motion rotates in latitude.
  2036. + The right mouse button moves the chosen point radially.
  2037. + 
  2038. + \vspace{.1 in}
  2039. + To understand the 3-D picture's relation to the four-dimensional vector,
  2040. + consider how a 2-D person could specify a direction in 3-D space.
  2041. + For each direction in 3-space, there's a point on the surface of a unit sphere
  2042. + ($x^2 + y^2 + z^2 = 1$).  A 2-D person could choose a point on the
  2043. + unit disk $x^2 + y^2 \le 1$, and take it to mean the vector whose endpoint
  2044. + on the sphere lies directly above or below that point.  The disk's center
  2045. + corresponds to the north (or south) pole of the sphere, and the edge of the
  2046. + disk to the sphere's equator.  Generally, $z = \sqrt{1 - x^2 - y^2}$.
  2047. + How to choose between the positive and negative hemispheres?
  2048. + Note that for every direction with negative $z$ component there's
  2049. + an exactly opposite direction with $z > 0$.  For many purposes,
  2050. + e.g. orthogonal projection or slicing, opposite directions are equivalent,
  2051. + so we can simply limit $z$ to a single hemisphere.
  2052. + 
  2053. + The fouraxis object lets you choose a point in the unit 3-ball
  2054. + with $x^2 + y^2 + z^2 \le 1$, and computes $w$ to create a unit 4-vector
  2055. + lying in the $w \ge 0$ hemisphere.
  2056. + 
  2057. + 
  2058. + \vspace{.1 in}
  2059. + In some applications you only want the fouraxis to be returned to the
  2060. + application program when the user releases the mouse, i.e., not all the time.
  2061. + The routine
  2062. + \begin{verbatim}
  2063. +    void fl_set_fouraxis_return(FL_OBJECT *obj, int always)
  2064. + \end{verbatim}
  2065. + controls this; set {\em always} to FALSE to get this effect.
  2066. + 
  2067. + 
  2068. + \subsubsection*{Other routines}
  2069. + 
  2070. + To set the value of the fouraxis, use the routines:
  2071. + 
  2072. + \begin{verbatim}
  2073. +    void fl_set_fouraxis(FL_OBJECT *obj, float x, float y, float z)
  2074. + 
  2075. +    void fl_set_fouraxis_basis(FL_OBJECT *obj, float *matrix)
  2076. + \end{verbatim}
  2077. + 
  2078. + The first form just sets the $(x,y,z)$ components, computing $w$ to form
  2079. + a unit vector.  The second form supplies a complete 4x4 basis matrix;
  2080. + the fouraxis object orthogonalizes it (perturbing the matrix if it was
  2081. + nearly singular) and uses the fourth column as the chosen $(x,y,z,w)$ vector.
  2082. + (The user-supplied matrix is not changed.)
  2083. + Orthogonalization begins with the fourth column, so if that's already a unit
  2084. + vector, it becomes the exactly the chosen vector.
  2085. + The matrix is assumed in row-major order, i.e. its "fourth column" is
  2086. + $matrix[4*j + 3]$ for $0 \le j \le 3$.
  2087. + 
  2088. + \vspace{.1 in}
  2089. + To obtain the current values of the fouraxis, use
  2090. + 
  2091. + \begin{verbatim}
  2092. +    void fl_get_fouraxis(FL_OBJECT *obj,
  2093. +             float *x, float *y, float *z, float *w)
  2094. + 
  2095. +    void fl_get_fouraxis_basis(FL_OBJECT *obj, float *matrix)
  2096. + \end{verbatim}
  2097. + 
  2098. + fl\_get\_fouraxis() returns the current components of the chosen vector.
  2099. + fl\_get\_fouraxis\_basis() returns a complete orthonormal basis, whose
  2100. + fourth column is the chosen vector.
  2101. + 
  2102. + \vspace{.1 in}
  2103. + The wireframe sphere's appearance may be adjusted with
  2104. + \begin{verbatim}
  2105. +     void fl_set_fouraxis_grid(FL_OBJECT *obj, int lat, int lon, int color)
  2106. +     void fl_get_fouraxis_grid(FL_OBJECT *obj, int *lat, int *lon, int *color)
  2107. + \end{verbatim}
  2108. + specifying respectively the number of latitude and longitude circles
  2109. + and their color; defaults are 9, 12, and 0 (black).
  2110. + \verb+fl_set_fouraxis_grid()+
  2111. + sets the values; \verb+fl_get_fouraxis_grid()+ returns current values.
  2112. + 
  2113. + \subsubsection*{Attributes}
  2114. + 
  2115. + Color1 controls the color of the box (default gray),
  2116. + color2 is the color of the radial vector (default red).
  2117. + 
  2118. + \subsubsection*{Remarks}
  2119. + 
  2120. + Demos appear in demof01.c and demof02.c.
  2121. + 
  2122. + \vspace{.1 in}
  2123. + The orthogonal blue axes bear no relation to the other vectors
  2124. + in the orthonormal basis; they're simply a perspective guide!
  2125. + 
  2126. + \vspace {.1 in}
  2127. + The basis matrix might be useful in applications which take a
  2128. + 3-D projection of a 4-D object.  The 4x4 matrix $M$ specifies
  2129. + a change of basis into a coordinate system whose fourth coordinate
  2130. + is along the vector chosen with the fouraxis widget.
  2131. + It's easy to construct either orthogonal or perspective projections into
  2132. + 3-space using the basis.  Given a 4-component column vector $(x,y,z,w)$
  2133. + representing a point $p$, let the product $M p = (x',y',z',w')$.
  2134. + For orthogonal projection, just discard $w'$: $(x',y',z')$ is the result of
  2135. + projecting $p$.  For perspective projection, you'll need to specify a place
  2136. + to project from; choose some constant $w'_0$, which should be outside the
  2137. + range of $w'$ values of the 4-D object.  The further $w'_0$ is from the
  2138. + object's $w'$ range, the less the perspective distortion.
  2139. + A perspective projection of $p$ is then $(x',y',z')/(w' - w'_0)$.
  2140. + 
  2141. + The basis' $(x',y',z')$ directions are somewhat arbitrary.
  2142. + The widget tries to change them as little as possible
  2143. + from their initial condition (the identity matrix), or from the
  2144. + latest state set with \verb+fl_set_fouraxis_basis()+.
  2145. + 
  2146. + \vspace{.1 in}
  2147. + Two experimental fouraxis types exist, which use different
  2148. + perspective cues to show where the vector's tip lies in the 3-ball.
  2149. + \verb+FL_CIRCLE_FOURAXIS+ simply draws a solid blue circle, showing the
  2150. + sphere's intersection with the plane normal to the chosen vector.
  2151. + \verb+FL_SPOKED_FOURAXIS+ shows a circle with five radial spokes.  Neither one
  2152. + looks as good as \verb+FL_NORMAL_FOURAXIS+ to my eye.
  2153. + 
  2154.  
  2155.     ... create new file colorwheel.h ...
  2156. *** /dev/null    Wed Oct 20 19:15:53 1993
  2157. --- new/FORMS/INCLUDE/colorwheel.h    Wed Dec 30 16:55:33 1992
  2158. ***************
  2159. *** 0 ****
  2160. --- 1,24 ----
  2161. + #ifndef COLORWHEEL_H
  2162. + #define COLORWHEEL_H
  2163. + 
  2164. + #define FL_COLORWHEEL_BW         FL_BUTTON_BW
  2165. + 
  2166. + #define FL_COLORWHEEL_CURSOR        .025
  2167. + 
  2168. + #define FL_COLORWHEEL             1492
  2169. + #define FL_NORMAL_COLORWHEEL         0
  2170. + 
  2171. + FL_OBJECT *fl_create_colorwheel(int type, float x, float y, float w,
  2172. +                 float h, char label[]);
  2173. + FL_OBJECT *fl_add_colorwheel(int type, float x, float y, float w, float h,
  2174. +                char label[]);
  2175. + 
  2176. + void fl_set_colorwheel(FL_OBJECT *obj, float *color);
  2177. + void fl_set_colorwheel_intensity(FL_OBJECT *obj, float intensity);
  2178. + void fl_set_colorwheel_alpha(FL_OBJECT *obj, float alpha);
  2179. + 
  2180. + void fl_get_colorwheel(FL_OBJECT *obj, float *color);
  2181. + float fl_get_colorwheel_intensity(FL_OBJECT *obj);
  2182. + float fl_get_colorwheel_alpha(FL_OBJECT *obj);
  2183. +      
  2184. + #endif
  2185.  
  2186.    ... create new file fouraxis.h ...
  2187. *** /dev/null    Wed Oct 20 19:15:53 1993
  2188. --- new/FORMS/INCLUDE/fouraxis.h    Mon Aug 31 11:09:53 1992
  2189. ***************
  2190. *** 0 ****
  2191. --- 1,41 ----
  2192. + /************   Object Class: Fouraxis (unit vector in 4-space)  ************/
  2193. + 
  2194. + /***** Class    *****/
  2195. + 
  2196. + #define FL_FOURAXIS        1034
  2197. + 
  2198. + /***** Types    *****/
  2199. + 
  2200. + #define FL_NORMAL_FOURAXIS    0
  2201. + #define    FL_CIRCLE_FOURAXIS    1
  2202. + #define    FL_SPOKED_FOURAXIS    2
  2203. + 
  2204. + /***** Defaults *****/
  2205. + 
  2206. + #define FL_FOURAXIS_BOXTYPE    FL_DOWN_BOX
  2207. + #define FL_FOURAXIS_COL1    FL_COL1
  2208. + #define FL_FOURAXIS_COL2    1
  2209. + #define FL_FOURAXIS_LCOL    FL_LCOL
  2210. + #define FL_FOURAXIS_ALIGN    FL_ALIGN_BOTTOM
  2211. + 
  2212. + /***** Others   *****/
  2213. + 
  2214. + #define FL_FOURAXIS_BW        FL_BOUND_WIDTH
  2215. + 
  2216. + /***** Routines *****/
  2217. + 
  2218. + FL_OBJECT    *fl_create_fouraxis(int, float, float, float, float, char []);
  2219. + FL_OBJECT    *fl_add_fouraxis(int, float, float, float, float, char []);
  2220. + 
  2221. +         /* Set direction vector.  w chosen to form unit vector */
  2222. + void     fl_set_fouraxis(FL_OBJECT *, float x, float y, float z);
  2223. + void     fl_get_fouraxis(FL_OBJECT *, float *xp, float *yp, float *zp, float *wp);
  2224. +         /* Also maintains an orthonormal basis matrix, with column 3
  2225. +          * (w) a unit vector in the chosen direction
  2226. +          * and other columns chosen appropriately.
  2227. +          */
  2228. + void    fl_get_fouraxis_basis(FL_OBJECT *, float * /* really float[4][4] */);
  2229. + void    fl_set_fouraxis_basis(FL_OBJECT *, float * /* really float[4][4] */);
  2230. + 
  2231. + void     fl_set_fouraxis_return(FL_OBJECT *, int);
  2232. + 
  2233.  
  2234.    ... create new file colorwheel.c ...
  2235. *** /dev/null    Wed Oct 20 19:15:53 1993
  2236. --- new/FORMS/colorwheel.c    Thu Oct 14 19:43:18 1993
  2237. ***************
  2238. *** 0 ****
  2239. --- 1,307 ----
  2240. + #include <stdio.h>
  2241. + #include <limits.h>
  2242. + #include <math.h>
  2243. + #include <gl.h>
  2244. + #include "forms.h"
  2245. + 
  2246. + /* The colors at the vertices of the hexagon */
  2247. + static float colors[][4] = {{1, 1, 1, 1},
  2248. +                   {1, 0, 0, 1}, {1, 1, 0, 1}, {0, 1, 0, 1},
  2249. +                   {0, 1, 1, 1}, {0, 0, 1, 1}, {1, 0, 1, 1}};
  2250. + /* The vertices of the unit hexagon */
  2251. + static float verts[7][2];
  2252. + 
  2253. + 
  2254. + /* 
  2255. +  * obj->spec contains:
  2256. +  * 14 floats containing the center followed by the vertices of the hexagon
  2257. +  * 2 floats containing the position of the pointer in the hexagon
  2258. +  */
  2259. + /* These macros rely on the object in question being stored in obj */
  2260. + typedef struct {
  2261. +   float pointer[2];
  2262. +   float intensity;
  2263. +   float alpha;
  2264. +   float radius;
  2265. +   float colors[7][4];
  2266. + } SpecStruct;
  2267. + 
  2268. + #define NEWRADIUS(a)    (((a)->w < (a)->h ? (a)->w/2.0 : (a)->h/2.0))
  2269. + 
  2270. + #define CURSOR_RADIUS    .95
  2271. + 
  2272. + #define SPEC_SIZE    (sizeof(SpecStruct))
  2273. + #define VERT         (((SpecStruct *)obj->spec)->vert)
  2274. + #define POINTER     (((SpecStruct *)obj->spec)->pointer)
  2275. + #define INTENSITY    (((SpecStruct *)obj->spec)->intensity)
  2276. + #define ALPHAVAL    (((SpecStruct *)obj->spec)->alpha)
  2277. + #define RADIUS        (((SpecStruct *)obj->spec)->radius)
  2278. + #define COLOR        (((SpecStruct *)obj->spec)->colors)
  2279. + 
  2280. + #define MIN(a, b)     ((a) < (b) ? (a) : (b))
  2281. + #define MAX(a, b)     ((a) > (b) ? (a) : (b))
  2282. + 
  2283. + #define ONE(a)        (MIN(MAX((a), 0.0), 1.0))
  2284. + 
  2285. + #define MAX3(a, b, c) \
  2286. + ((a) > (b) ? \
  2287. +  ((a) > (c) ? (a) : (c)) : \
  2288. +  ((b) > (c) ? (b) : (c)))
  2289. + 
  2290. + #define MIN3(a, b, c) \
  2291. + ((a) < (b) ? \
  2292. +  ((a) < (c) ? (a) : (c)) : \
  2293. +  ((b) < (c) ? (b) : (c))) \
  2294. + 
  2295. + static int handle_colorwheel(FL_OBJECT *obj, int event, float mx, float my, 
  2296. +                char key);
  2297. + static float scale_to_hexagon(FL_OBJECT *obj, float x, float y);
  2298. + 
  2299. + FL_OBJECT *fl_create_colorwheel(int type, float x, float y, float w,
  2300. +                 float h, char label[])
  2301. + {
  2302. +   FL_OBJECT *obj;
  2303. + 
  2304. +   /* We might be recomputing these, but c'est la vie */
  2305. +   verts[0][0] = verts[0][1] = 0.0;
  2306. +   
  2307. +   verts[1][0] = 1.0;
  2308. +   verts[4][0] = -verts[1][0];
  2309. +   verts[1][1] = verts[4][1] = 0.0;
  2310. +   
  2311. +   verts[2][0] = verts[6][0] = cos(M_PI / 3.0);
  2312. +   verts[3][0] = verts[5][0] = -verts[2][0];
  2313. +   verts[2][1] = verts[3][1] = sin(M_PI / 3.0);
  2314. +   verts[5][1] = verts[6][1] = -verts[2][1];
  2315. + 
  2316. +   obj = fl_make_object(FL_COLORWHEEL, type, x, y, w, h, label, 
  2317. +                handle_colorwheel);
  2318. + 
  2319. +   obj->boxtype = FL_UP_BOX;
  2320. +   obj->lcol = BLACK;
  2321. +   obj->col1 = FL_BUTTON_COL1;
  2322. +   obj->col2 = BLACK;
  2323. +   obj->align = FL_ALIGN_BOTTOM;
  2324. + 
  2325. +   obj->spec = (int *)malloc(SPEC_SIZE);
  2326. + 
  2327. +   POINTER[0] = POINTER[1] = 0.0;
  2328. +   RADIUS = NEWRADIUS(obj);
  2329. + 
  2330. +   INTENSITY = 1.0;
  2331. +   ALPHAVAL = 1.0;
  2332. + 
  2333. +   return obj;
  2334. + }
  2335. + 
  2336. + FL_OBJECT *fl_add_colorwheel(int type, float x, float y, float w, float h,
  2337. +                char label[])
  2338. + {
  2339. +   FL_OBJECT *obj;
  2340. +   obj = fl_create_colorwheel(type, x, y, w, h, label);
  2341. +   fl_add_object(fl_current_form, obj);
  2342. +   return obj;
  2343. + }
  2344. + 
  2345. + static int handle_colorwheel(FL_OBJECT *obj, int event, float mx, float my, 
  2346. +                char key)
  2347. + {
  2348. +   int i;
  2349. +   int center[2];
  2350. +   float scalef;
  2351. + 
  2352. +   switch(event) {
  2353. +   case FL_DRAW:
  2354. + 
  2355. +     fl_drw_box(obj->boxtype, obj->x, obj->y, obj->w, obj->h, obj->col1,
  2356. +            FL_COLORWHEEL_BW);
  2357. +     for (i = 0; i < 7; i++) {
  2358. +       COLOR[i][0] = colors[i][0] * INTENSITY;
  2359. +       COLOR[i][1] = colors[i][1] * INTENSITY;
  2360. +       COLOR[i][2] = colors[i][2] * INTENSITY;
  2361. +       COLOR[i][3] = ALPHAVAL;
  2362. +     }
  2363. +     blendfunction(BF_SA, BF_MSA);
  2364. + 
  2365. +     center[0] = obj->x + obj->w / 2.0;
  2366. +     center[1] = obj->y + obj->h / 2.0;
  2367. +     pushmatrix();
  2368. +     translate(center[0], center[1], 0.0);
  2369. +     RADIUS = NEWRADIUS(obj);
  2370. +     scale(RADIUS, RADIUS, RADIUS);
  2371. +     for (i = 0; i < 6; i++) {
  2372. +       bgnpolygon();
  2373. +       c4f(COLOR[0]);
  2374. +       v2f(verts[0]);
  2375. +       
  2376. +       c4f(COLOR[i + 1]);
  2377. +       v2f(verts[i+1]);
  2378. + 
  2379. +       c4f(COLOR[((i+1)%6) + 1]);
  2380. +       v2f(verts[((i+1)%6)+1]); 
  2381. +       endpolygon();
  2382. +     }
  2383. +     scale(CURSOR_RADIUS, CURSOR_RADIUS, CURSOR_RADIUS);
  2384. +     fl_rect(POINTER[0] - FL_COLORWHEEL_CURSOR, 
  2385. +         POINTER[1] - FL_COLORWHEEL_CURSOR, 
  2386. +         2.0 * FL_COLORWHEEL_CURSOR, 2.0 * FL_COLORWHEEL_CURSOR, 
  2387. +         obj->col2); 
  2388. +     popmatrix();
  2389. +     fl_drw_text_beside(obj->align, obj->x, obj->y, obj->w, obj->h,
  2390. +                obj->lcol, obj->lsize, obj->lstyle, obj->label);
  2391. +     return 0;
  2392. +   case FL_PUSH:
  2393. +   case FL_RELEASE:
  2394. +   case FL_MOUSE:
  2395. +     RADIUS = NEWRADIUS(obj);
  2396. +     POINTER[0] = (mx - obj->w/2.0 - obj->x) / RADIUS;
  2397. +     POINTER[1] = (my - obj->h/2.0 - obj->y) / RADIUS;
  2398. +     
  2399. +     /* Get it within the hexagon vertically */
  2400. +     scalef = scale_to_hexagon(obj, POINTER[0], POINTER[1]);
  2401. +     if (scalef < 1.0) {
  2402. +       POINTER[0] *= scalef;
  2403. +       POINTER[1] *= scalef;
  2404. +     }
  2405. +     
  2406. +     fl_redraw_object(obj);
  2407. +     return 1;
  2408. +   default: 
  2409. +     return 0;
  2410. +   }
  2411. + }
  2412. + 
  2413. + void fl_set_colorwheel_alpha(FL_OBJECT *obj, float alpha) {
  2414. +   ALPHAVAL = ONE(alpha);
  2415. +   fl_redraw_object(obj);
  2416. + }
  2417. + 
  2418. + float fl_get_colorwheel_alpha(FL_OBJECT *obj) {
  2419. +   return ALPHAVAL;
  2420. + }
  2421. + 
  2422. + void fl_set_colorwheel_intensity(FL_OBJECT *obj, float intensity) {
  2423. +   INTENSITY = ONE(intensity);
  2424. +   fl_redraw_object(obj);
  2425. + }
  2426. + 
  2427. + float fl_get_colorwheel_intensity(FL_OBJECT *obj) {
  2428. +   return INTENSITY;
  2429. + }
  2430. + 
  2431. + void fl_set_colorwheel(FL_OBJECT *obj, float *color)
  2432. + {
  2433. +   float h, s, v;
  2434. +   float min, max, delta, scale;
  2435. +   float r = ONE(color[0]), g = ONE(color[1]), b = ONE(color[2]);
  2436. + 
  2437. +   max = MAX3(r, g, b);
  2438. +   min = MIN3(r, g, b);
  2439. +   v = max;
  2440. +   if (max > .001) s = (max - min) / max;
  2441. +   else s = 0.0;
  2442. + 
  2443. +   if (s < .001) POINTER[0] = POINTER[1] = 0.0;
  2444. +   else {
  2445. +     delta = max - min;
  2446. +     if (r == max) h = (g - b) / delta;
  2447. +     else if (g == max) h = 2.0 + (b - r) / delta;
  2448. +     else if (b == max) h = 4.0 + (r - g) / delta;
  2449. +     h *= 60.0;
  2450. +     if (h < .001) h += 360.0;
  2451. + 
  2452. +     h = (h / 180.0) * M_PI;
  2453. +     scale = scale_to_hexagon(obj, cos(h), sin(h));
  2454. +     POINTER[0] = cos(h) * s * scale;
  2455. +     POINTER[1] = sin(h) * s * scale;
  2456. +   }
  2457. + 
  2458. +   INTENSITY = v;
  2459. + 
  2460. +   fl_redraw_object(obj);
  2461. + }
  2462. + 
  2463. + void fl_get_colorwheel(FL_OBJECT *obj, float *color) 
  2464. + {
  2465. +   int i;
  2466. +   float f, p, q, t;
  2467. +   float h, s, v;
  2468. +   float radius;
  2469. + 
  2470. +   v = INTENSITY;
  2471. +   if (fabs(POINTER[0]) < .001 && fabs(POINTER[1]) < .001) {
  2472. +     color[0] = color[1] = color[2] = v;
  2473. +     return;
  2474. +   }
  2475. +   s = 1.0 / scale_to_hexagon(obj, POINTER[0], POINTER[1]);
  2476. +   /* The point must already be inside the hexagon, but we may be suffering
  2477. +    * from round-off error */
  2478. +   if (s > 1.0) s = 1.0;
  2479. + 
  2480. +   h = (atan2(POINTER[1],POINTER[0]) / M_PI) * 180.0;
  2481. +   if (h < 0.0) h = 360.0 + h;
  2482. +   if (h >= 360.0) h = 0.0;
  2483. +   h = h / 60.0;
  2484. +   i = floor(h);
  2485. +   f = h - (float)i;
  2486. +   p = v * (1.0 - s);
  2487. +   q = v * (1.0 - (s * f));
  2488. +   t = v * (1.0 - (s * (1.0 - f)));
  2489. +   switch(i) {
  2490. +   case 0:
  2491. +     color[0] = v;
  2492. +     color[1] = t;
  2493. +     color[2] = p; 
  2494. +     break;
  2495. +   case 1: 
  2496. +     color[0] = q;
  2497. +     color[1] = v;
  2498. +     color[2] = p;
  2499. +     break;
  2500. +   case 2:
  2501. +     color[0] = p;
  2502. +     color[1] = v;
  2503. +     color[2] = t;
  2504. +     break;
  2505. +   case 3:
  2506. +     color[0] = p;
  2507. +     color[1] = q;
  2508. +     color[2] = v;
  2509. +     break;
  2510. +   case 4:
  2511. +     color[0] = t;
  2512. +     color[1] = p;
  2513. +     color[2] = v;
  2514. +     break;
  2515. +   case 5:
  2516. +     color[0] = v;
  2517. +     color[1] = p;
  2518. +     color[2] = q;
  2519. +     break;
  2520. +   default:
  2521. +     break;
  2522. +   }
  2523. + 
  2524. + }
  2525. + 
  2526. + /* 
  2527. +  * This finds the t that should multiply x and y to place the point
  2528. +  * on the hexagon.
  2529. +  * Returns 1000 ("large") if x == 0 && y == 0
  2530. +  * < 1.0 = point outside
  2531. +  * > 1.0 = point inside
  2532. + */
  2533. + #define HEX 1.73205    /* sqrt(3) */
  2534. + static float scale_to_hexagon(FL_OBJECT *obj, float x, float y)
  2535. + {
  2536. +   x = fabs(x);
  2537. +   y = fabs(y);
  2538. +   if (y == 0) {
  2539. +     return x < .001 ? 1000 : 1/x;    /* Scale X to horiz hexagon corner */
  2540. +   } else if (x*HEX < y) {
  2541. +     return .5*HEX/y;        /* Scale Y to top of hexagon, at sqrt(3)/2 */
  2542. +   } else {
  2543. +     return HEX/(y + HEX*x);        /* Scale to slanted hexagon side */
  2544. +   }
  2545. + }
  2546. + #undef HEX
  2547.  
  2548.  ... create new file fouraxis.c ...
  2549. *** /dev/null    Wed Oct 20 19:15:53 1993
  2550. --- new/FORMS/fouraxis.c    Fri Nov  6 10:14:05 1992
  2551. ***************
  2552. *** 0 ****
  2553. --- 1,397 ----
  2554. + /************************************************************************
  2555. +  *                                    *
  2556. +  *  Object class: FOURAXIS                        *
  2557. +  *                                    *
  2558. +  *  Written by: Stuart Levy; adapted from Mark Overmars' POSITIONER    *
  2559. +  *                                    *
  2560. +  *  Version 1.1                              *
  2561. +  *  Date:   28 May 1992                            *
  2562. +  ************************************************************************/
  2563. + 
  2564. + #include <gl/gl.h>
  2565. + #include <gl/device.h>
  2566. + #include <sys/types.h>
  2567. + #include <math.h>
  2568. + #include <malloc.h>
  2569. + #include "forms.h"
  2570. + 
  2571. + /* State of a fouraxis */
  2572. + typedef struct {
  2573. +    int gridcolor;            /* color for grid drawing */
  2574. +    int gridlong, gridlat;        /* how many grid circles to draw */
  2575. +    int colorless;            /* Crosses in red/green/blue, else col2 */
  2576. +    int allout;                /* All crosses extend to sphere edge */
  2577. +     
  2578. +    float rho, theta, phi;        /* user-interface controls */
  2579. +    float omx, omy;            /* prev mouse position */
  2580. +    int   whatsdown;            /* -1: omx,omy invalid.
  2581. +                      * 0: left mouse down.  1: right mouse.
  2582. +                      */
  2583. +    float T[4][4];            /* Initial basis matrix, which we */
  2584. +                     /* should try to approximate */
  2585. +    int always;                    /* whether always returning value */
  2586. + } SPEC;
  2587. + 
  2588. + 
  2589. + #define    X 0
  2590. + #define    Y 1
  2591. + #define Z 2
  2592. + #define W 3
  2593. + 
  2594. + static void orthog4(float T[4][4]);
  2595. + static void transpose(float *src, float *dst);
  2596. + 
  2597. + 
  2598. + static void drawsphere(register SPEC *sp)
  2599. + {
  2600. +   register int i;
  2601. +   static int setls = 0;
  2602. + 
  2603. +   if(!setls) {
  2604. +     deflinestyle(FL_FOURAXIS, 0xCCCC);
  2605. +     setls = 1;
  2606. +   }
  2607. +   pushattributes();
  2608. +   pushmatrix();
  2609. +   setlinestyle(FL_FOURAXIS);
  2610. +   for(i = sp->gridlong; --i >= 0; ) {
  2611. +     circ(0.0, 0.0, 1.0);
  2612. +     rot(180./sp->gridlong, 'y');
  2613. +   }
  2614. +   popmatrix();
  2615. +   pushmatrix();
  2616. +   rot(90., 'x');
  2617. +   circ(0.0, 0.0, 1.0);
  2618. +   for(i = sp->gridlat; --i > 0; ) {
  2619. +     float s = sin(M_PI_2 * i / sp->gridlat);
  2620. +     float c = fsqrt(1 - s*s);
  2621. + 
  2622. +     translate(0.0, 0.0, c);
  2623. +     circ(0.0, 0.0, s);
  2624. +     translate(0.0, 0.0, -2*c);
  2625. +     circ(0.0, 0.0, s);
  2626. +     translate(0.0, 0.0, c);
  2627. +   }
  2628. +   popmatrix();
  2629. +   popattributes();
  2630. + }
  2631. +  
  2632. + static void drawaxis(register SPEC *sp, FL_OBJECT *ob)
  2633. + {
  2634. +   float v = fsqrt(1 - sp->rho * sp->rho);
  2635. +   int i;
  2636. + 
  2637. +   pushmatrix();
  2638. +   pushattributes();
  2639. +   rot(sp->theta, 'y');
  2640. +   rot(sp->phi, 'z');
  2641. +   move(0., 0., 0.);
  2642. +   draw(sp->allout ? 1. : sp->rho, 0., 0.);
  2643. + 
  2644. +   switch(ob->type & 7) {
  2645. +   case FL_NORMAL_FOURAXIS:
  2646. +     if(!sp->colorless) fl_color(4);
  2647. +     move(sp->rho, 0., 0.);
  2648. +     draw(sp->rho, v, 0.);
  2649. + 
  2650. +     move(sp->rho, 0., 0.);
  2651. +     draw(sp->rho, 0., v);
  2652. +     break;
  2653. +   case FL_SPOKED_FOURAXIS:
  2654. +   case FL_CIRCLE_FOURAXIS:
  2655. +     if(!sp->colorless) fl_color(4);
  2656. +     translate(sp->rho, 0., 0.);
  2657. +     rot(90., 'y');
  2658. +     circ(0., 0., v);
  2659. +     if((ob->type & 7) == FL_CIRCLE_FOURAXIS)
  2660. +         break;
  2661. +     setlinestyle(FL_FOURAXIS);
  2662. +     for(i=0; i<5; i++) {
  2663. +       move(0., 0., 0.);
  2664. +       draw(v, 0., 0.);
  2665. +       rot(72., 'z');
  2666. +     }
  2667. +   }
  2668. + 
  2669. +   popattributes();
  2670. +   popmatrix();
  2671. + }
  2672. +     
  2673. + static void draw_fouraxis(register FL_OBJECT *ob)
  2674. + /* Draws a fouraxis */
  2675. + {
  2676. +   SPEC *sp = ((SPEC *)(ob->spec));
  2677. +   Matrix T;
  2678. + 
  2679. +   float wx, wy;
  2680. + 
  2681. +   wx = FL_FOURAXIS_BW;
  2682. +   wy = FL_FOURAXIS_BW;
  2683. +   fl_drw_box(ob->boxtype,ob->x,ob->y,ob->w,ob->h,ob->col1,FL_FOURAXIS_BW);
  2684. +   fl_drw_text_beside(ob->align,ob->x,ob->y,ob->w,ob->h,
  2685. +                         ob->lcol,ob->lsize,ob->lstyle,ob->label);
  2686. +   pushmatrix();
  2687. +   pushviewport();
  2688. +   pushattributes();
  2689. +   viewport(ob->x + wx, ob->x + ob->w - wx, ob->y + wy, ob->y + ob->h - wy);
  2690. +   perspective(900, (float)(ob->w - 2*wx) / (ob->h - 2*wy), .5, 4);
  2691. +   translate(0., 0., -1.5);
  2692. +   fl_color(sp->gridcolor);
  2693. +   drawsphere(sp);
  2694. +   linewidth(2);
  2695. +   fl_color(ob->col2);
  2696. +   drawaxis(sp, ob);
  2697. +   popattributes();
  2698. +   popviewport();
  2699. +   popmatrix();
  2700. + }
  2701. + 
  2702. + static int handle_mouse(FL_OBJECT *ob,float mx,float my, int key)
  2703. + /* Handle a mouse position change */
  2704. + {
  2705. +   register SPEC *sp = ((SPEC *)(ob->spec));
  2706. +   float du, dv;
  2707. + 
  2708. +   du = (mx - sp->omx) / ob->w;
  2709. +   dv = (my - sp->omy) / ob->h;
  2710. +   sp->omx = mx;
  2711. +   sp->omy = my;
  2712. +   if(sp->whatsdown < 0) {
  2713. +     sp->whatsdown = getbutton(RIGHTMOUSE);
  2714. +     return 0;
  2715. +   }
  2716. + 
  2717. +   if(du == 0 && dv == 0)
  2718. +     return 0;
  2719. + 
  2720. +   if(sp->whatsdown) {
  2721. +     sp->rho += .5 * (du-dv);  /* rightmouse: rho (x motion) / w (y motion) */
  2722. +     if(sp->rho < 0) sp->rho = 0;
  2723. +     else if(sp->rho > 1) sp->rho = 1;
  2724. +   } else {
  2725. +     sp->theta += 180. * du;   /* leftmouse: theta (x) / phi (y) */
  2726. +     sp->phi += 90. * dv;
  2727. +     if(sp->phi > 90.) sp->phi = 90.;
  2728. +     else if(sp->phi < -90.) sp->phi = -90.;
  2729. +   }
  2730. +   fl_redraw_object(ob);
  2731. + 
  2732. +   return 1;
  2733. + }
  2734. + 
  2735. + static int handle_fouraxis(FL_OBJECT *ob,int event,float mx,float my,int key)
  2736. + /* Handles an event */
  2737. + {
  2738. +   SPEC *sp = (SPEC *) ob->spec;
  2739. +   switch (event)
  2740. +   {
  2741. +     case FL_DRAW:
  2742. +     draw_fouraxis(ob);
  2743. +     return 0;
  2744. +     case FL_PUSH:
  2745. +     case FL_MOUSE:
  2746. +         return ( handle_mouse(ob,mx,my,key) && sp->always);
  2747. +     case FL_RELEASE:
  2748. +     sp->whatsdown = -1;
  2749. +         return (! sp->always);
  2750. +   }
  2751. +   return 0;
  2752. + }
  2753. + 
  2754. + /*------------------------------*/
  2755. + 
  2756. + FL_OBJECT *fl_create_fouraxis(int type,float x,float y,float w,float h,char label[])
  2757. + /* creates an object */
  2758. + {
  2759. +   FL_OBJECT *ob;
  2760. +   register SPEC *sp;
  2761. + 
  2762. +   ob = fl_make_object(FL_FOURAXIS,type,x,y,w,h,label,handle_fouraxis);
  2763. +   ob->boxtype = FL_FOURAXIS_BOXTYPE;
  2764. +   ob->col1 = FL_FOURAXIS_COL1;
  2765. +   ob->col2 = FL_FOURAXIS_COL2;
  2766. +   ob->align = FL_FOURAXIS_ALIGN;
  2767. +   ob->lcol = FL_FOURAXIS_LCOL;
  2768. + 
  2769. +   ob->spec = (int *) malloc(sizeof(SPEC));
  2770. +   sp = (SPEC *)ob->spec;
  2771. +   sp->rho = 0.5;
  2772. +   sp->theta = 45.;
  2773. +   sp->phi = 45.;
  2774. +   sp->whatsdown = -1;
  2775. +   sp->gridlong = 12;    /* 24 meridians */
  2776. +   sp->gridlat = 9;    /* 18 parallels */
  2777. +   sp->gridcolor = 0;    /* black wireframe sphere */
  2778. +   sp->colorless = type & 8;
  2779. +   sp->allout = type & 0x10;
  2780. +   sp->always = TRUE;
  2781. +   bzero(sp->T, 16*sizeof(float));
  2782. + 
  2783. +   return ob;
  2784. + }
  2785. + 
  2786. + FL_OBJECT *fl_add_fouraxis(int type,float x,float y,float w,float h,char label[])
  2787. + /* Adds an object */
  2788. + {
  2789. +   FL_OBJECT *ob;
  2790. +   ob = fl_create_fouraxis(type,x,y,w,h,label);
  2791. +   fl_add_object(fl_current_form,ob);
  2792. +   return ob;
  2793. + }
  2794. + 
  2795. + void fl_set_fouraxis(FL_OBJECT *ob,float x, float y, float z)
  2796. + /* Aims the axis */
  2797. + {
  2798. +   register SPEC *sp = (SPEC *)ob->spec;
  2799. +   float xy2 = x*x + y*y;
  2800. +   register int i,j;
  2801. +   /* Map to rho, theta, phi */
  2802. +   sp->rho = fsqrt(xy2 + z*z);
  2803. +   sp->theta = (y == 0 && x == 0) ? 0 : (180/M_PI)*atan2(y,x);
  2804. +   sp->phi = (sp->rho == 0) ? 0 : (180/M_PI)*atan2(z, fsqrt(xy2));
  2805. + 
  2806. +   sp->T[W][X] = x;  sp->T[W][Y] = y;  sp->T[W][Z] = z;
  2807. +   sp->T[W][W] = fsqrt(1 - xy2 + z*z);
  2808. + 
  2809. +   fl_redraw_object(ob);
  2810. + }
  2811. + 
  2812. + 
  2813. + void fl_get_fouraxis(FL_OBJECT *ob,float *x, float *y, float *z, float *w)
  2814. + /* Returns the axis */
  2815. + {
  2816. +   register SPEC *sp = (SPEC *)ob->spec;
  2817. +   float r;
  2818. + 
  2819. +   *w = fsqrt(1 - sp->rho*sp->rho);
  2820. +   r = sp->rho * cos(sp->phi * M_PI/180);
  2821. +   *x = r * cos(sp->theta * M_PI/180);
  2822. +   *y = r * sin(sp->theta * M_PI/180);
  2823. +   *z = sp->rho * sin(sp->phi * M_PI/180);
  2824. + }
  2825. + 
  2826. + void fl_set_fouraxis_grid(FL_OBJECT *ob, int lat, int lon, int col)
  2827. + {
  2828. +   register SPEC *sp = (SPEC *)ob->spec;
  2829. +   if(lat >= 0) sp->gridlat = lat;
  2830. +   if(lon >= 0) sp->gridlong = lon;
  2831. +   if(col >= 0) sp->gridcolor = col;
  2832. + }
  2833. + 
  2834. + void fl_get_fouraxis_grid(FL_OBJECT *ob, int *lat, int *lon, int *col)
  2835. + {
  2836. +   register SPEC *sp = (SPEC *)ob->spec;
  2837. +   if(lat) *lat = sp->gridlat;
  2838. +   if(lon) *lon = sp->gridlong;
  2839. +   if(col) *col = sp->gridcolor;
  2840. + }
  2841. + 
  2842. + static void transpose(float *src, float *dst)
  2843. + {
  2844. +   register int i, j;
  2845. +   register float v;
  2846. + 
  2847. +   for(i=0; i<4; i++) for(j=0; j<4; j++)
  2848. +     dst[i*4+j] = src[j*4+i];
  2849. + }
  2850. + 
  2851. + void fl_set_fouraxis_basis(FL_OBJECT *ob, float *matrix)
  2852. + {
  2853. +   register SPEC *sp = (SPEC *)ob->spec;
  2854. +   float T[4][4];
  2855. + 
  2856. +   transpose(matrix, (float *)sp->T);
  2857. +   bcopy(sp->T, T, sizeof(T));
  2858. +   orthog4(T);
  2859. +   fl_set_fouraxis(ob, T[W][X], T[W][Y], T[W][Z]);
  2860. + }
  2861. + 
  2862. + void fl_get_fouraxis_basis(FL_OBJECT *ob, float *matrix)
  2863. + {
  2864. +   register SPEC *sp = (SPEC *)ob->spec;
  2865. +   float T[4][4];
  2866. + 
  2867. +   bcopy(sp->T, T, sizeof(T));
  2868. +   fl_get_fouraxis(ob, &T[W][X], &T[W][Y], &T[W][Z], &T[W][W]);
  2869. +   orthog4(T);
  2870. +   transpose((float *)T, matrix);
  2871. + }
  2872. + 
  2873. + void fl_set_fouraxis_return(FL_OBJECT *ob, int value)
  2874. + /* Sets whether to return value all the time */
  2875. + {
  2876. +   ((SPEC *)(ob->spec))->always = value;
  2877. + }
  2878. + 
  2879. + 
  2880. + #include <math.h>
  2881. + 
  2882. + typedef float Point[4];
  2883. + 
  2884. + #define DOT(a, b)    ((a)[0]*(b)[0] + (a)[1]*(b)[1] + (a)[2]*(b)[2] + (a)[3]*(b)[3])
  2885. + #define    VCOPY(src,dst)    bcopy((char*)(src), (char*)(dst), sizeof(Point))
  2886. + #define    VSCALE(s, dst) (dst)[0]*=s, (dst)[1]*=s, (dst)[2]*=s, (dst)[3]*=s
  2887. + 
  2888. + #define    VSSUB(src,s, dst) { register float t = s; \
  2889. +               (dst)[0] -= t*(src)[0], \
  2890. +               (dst)[1] -= t*(src)[1], \
  2891. +               (dst)[2] -= t*(src)[2], \
  2892. +               (dst)[3] -= t*(src)[3]; \
  2893. +             }
  2894. + 
  2895. + /*
  2896. +  * orthog4() accepts three 4-space vectors -- pw, pz, py -- and
  2897. +  * constructs an orthogonal basis of unit vectors X, Y, Z, W where
  2898. +  * W = normalized pw,
  2899. +  * Z is the normalized projection of pz on the space orthogonal to pw,
  2900. +  * Y is the normalized projection of py on the plane orthogonal to pw and pz,
  2901. +  * X is perpendicular to the other three.
  2902. +  * In degenerate cases (zero or nearly coplanar vectors pw, pz, py),
  2903. +  * the vectors are arbitrarily perturbed until they're distinct.
  2904. +  * Result is a 4x4 matrix representing a transformation from
  2905. +  * the supplied coordinate system to the newly constructed one.
  2906. +  * The vectors X, Y, Z, W appear as columns 0, 1, 2, 3 of the resulting matrix.
  2907. +  */
  2908. + static void
  2909. + orthog4(register float M[4][4])
  2910. + {
  2911. +     register float s;
  2912. +     register int k;
  2913. + 
  2914. +     s = DOT(M[3],M[3]);
  2915. +     if(s == 0)
  2916. +     M[3][3] = 1.0;
  2917. +     else {
  2918. +     s = 1/fsqrt(s);
  2919. +     VSCALE(s, M[3]);
  2920. +     }
  2921. + 
  2922. +     for(k = 2; ; k++, k %= 4) {
  2923. +     VSSUB(M[3], DOT(M[3],M[2]), M[2]);
  2924. +     if((s = DOT(M[2],M[2])) > 0.05)
  2925. +         break;
  2926. +     M[2][k] += 1.0;
  2927. +     }
  2928. + 
  2929. +     VSCALE(1/fsqrt(s), M[2]);
  2930. + 
  2931. +     for(k = 1; ; k++, k %= 4) {
  2932. +     VSSUB(M[3], DOT(M[3],M[1]), M[1]);
  2933. +     VSSUB(M[2], DOT(M[2],M[1]), M[1]);
  2934. +     s = DOT(M[1],M[1]);
  2935. +     if(s > 0.05)
  2936. +         break;
  2937. +     M[1][k] += 1.0;
  2938. +     }
  2939. + 
  2940. +     for(k = 0; ; k++, k %= 4) {
  2941. +     VSSUB(M[3], DOT(M[3],M[0]), M[0]);
  2942. +     VSSUB(M[2], DOT(M[2],M[0]), M[0]);
  2943. +     VSSUB(M[1], DOT(M[1],M[0]), M[0]);
  2944. +     if((s = DOT(M[0],M[0])) > 0.05)
  2945. +         break;
  2946. +     M[0][k] += 1.0;
  2947. +     }
  2948. +     VSCALE(1/fsqrt(s), M[0]);
  2949. + }
  2950. + 
  2951.