home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 2 / goldfish_vol2_cd1.bin / files / misc / sci / gfft / source / wbtime3d.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-06  |  11.2 KB  |  440 lines
  1. /***************************************************************************
  2.  *          Copyright (C) 1994  Charles P. Peterson                  *
  3.  *         4007 Enchanted Sun, San Antonio, Texas 78244-1254             *
  4.  *              Email: Charles_P_Peterson@fcircus.sat.tx.us                *
  5.  *                                                                         *
  6.  *          This is free software with NO WARRANTY.                  *
  7.  *          See gfft.c, or run program itself, for details.              *
  8.  *              Support is available for a fee.                      *
  9.  ***************************************************************************
  10.  *
  11.  * Program:     gfft--General FFT analysis
  12.  * File:        wbtime3d.c
  13.  * Purpose:     requester to set Time-3D parameters
  14.  * Author:      Charles Peterson (CPP)
  15.  * History:     18-March-1994 CPP; Created.
  16.  *               9-August-94 CPP (1.10); Auto Setup and Hidden 3D buttons
  17.  * Comments:    Workbench GUI.  Amiga Dependent!
  18.  */
  19.  
  20. #ifdef AMIGA  /* This module is AMIGA dependent */
  21.  
  22. #include <stdio.h>     /* sprintf() */
  23. #include <string.h>
  24.  
  25. /*
  26.  * Amiga includes
  27.  */
  28. #include <exec/types.h>
  29. #include <workbench/workbench.h>
  30. #include <intuition/intuition.h>
  31. #include <clib/intuition_protos.h>
  32. #include <clib/exec_protos.h>
  33. #include <dos.h> /* chkabort() */
  34.  
  35. /*
  36.  * GFFT includes
  37.  */
  38. #include "gfft.h"
  39. #include "settings.h"  /* for testing */
  40. #include "wbench.h"
  41.  
  42. /*
  43.  * External globals
  44.  */
  45. extern struct Window *dialog_window_p;
  46.  
  47. static struct Requester *time3d_rp = NULL;
  48.  
  49. static struct Gadget *help_time3d_gadgetp;
  50. static struct Gadget *set_up_1_gadgetp;
  51. static struct Gadget *time_segsize_gadgetp;
  52. static struct Gadget *time_segments_gadgetp;
  53. static struct Gadget *time_overlap_gadgetp;
  54. static struct Gadget *time_offset_gadgetp;
  55. static struct Gadget *rotx_gadgetp;
  56. static struct Gadget *rotz_gadgetp;
  57. static struct Gadget *reset_time3d_gadgetp;
  58. static struct Gadget *time3d_on_gadgetp;
  59. static struct Gadget *hidden3d_gadgetp;
  60. static struct Gadget *end_time3d_gadgetp;
  61. /* static struct Gadget *time3d_message_gadgetp; */
  62.  
  63. #define MAX_VAL_SIZE 30
  64.  
  65. #define SET_TIME3D_ON \
  66.   if (Time3D) radio_button__in (time3d_on_gadgetp, dialog_window_p);
  67.  
  68. void time3d_requester (void)
  69. {
  70.     struct IntuiMessage *message;
  71.     APTR *address = NULL;
  72.     ULONG class = 0;
  73.     UWORD qualifier = NULL;
  74.     APTR *next_address = NULL;
  75.     ULONG next_class = 0;
  76.     UWORD next_qualifier = NULL;
  77.     APTR string_gadget_being_set = NULL;
  78.     char string[MAX_VAL_SIZE];
  79.  
  80.     if (!time3d_rp)
  81.     {
  82.     gadget__begin (GTYP_REQGADGET);
  83. /*
  84.  * Setup Gadgets
  85.  */
  86.     help_time3d_gadgetp = text_button__new ("Help", 0, 0);
  87.  
  88.         set_up_1_gadgetp = text_button__new ("Auto Set-Up 1", 8, 0);
  89.  
  90.     string[0] = '\0';
  91.     if (TimeSegSize != NOT_SET)
  92.     {
  93.         sprintf (string, "%g", TimeSegSize);
  94.     }
  95.     time_segsize_gadgetp = string_gadget__new ("Time Segment Size:",
  96.                            string,
  97.                            MAX_VAL_SIZE,
  98.                            39, 0, 1);
  99.     string[0] = '\0';
  100.     if (TimeSegments != NOT_SET)
  101.     {
  102.         sprintf (string, "%g", TimeSegments);
  103.     }
  104.     time_segments_gadgetp = string_gadget__new ("Time Segment Count:",
  105.                             string,
  106.                             MAX_VAL_SIZE,
  107.                             39, 0, 2);
  108.  
  109.     string[0] = '\0';
  110.     if (TimeOffset != NOT_SET)
  111.     {
  112.         sprintf (string, "%g", TimeOffset);
  113.     }
  114.     time_offset_gadgetp = string_gadget__new ("Time Segment Offset:",
  115.                           string,
  116.                           MAX_VAL_SIZE,
  117.                           39, 0, 3);
  118.  
  119.  
  120.     if (TimeOffset == NOT_SET)
  121.     {
  122.         sprintf (string, "%g", TimeOverlap);
  123.     }
  124.     else
  125.     {
  126.         string[0] = '\0';
  127.     }
  128.     time_overlap_gadgetp = string_gadget__new ("Time Segment Overlap:",
  129.                            string,
  130.                            MAX_VAL_SIZE,
  131.                            39, 0, 4);
  132.  
  133.     sprintf (string, "%g", RotX);
  134.     rotx_gadgetp = string_gadget__new ("X Rotation:",
  135.                        string,
  136.                        MAX_VAL_SIZE,
  137.                        18, 0, 5);
  138.  
  139.     sprintf (string, "%g", RotZ);
  140.     rotz_gadgetp = string_gadget__new ("Z Rotation:",
  141.                        string,
  142.                        MAX_VAL_SIZE,
  143.                        18, 21, 5);
  144.  
  145.  
  146.     reset_time3d_gadgetp = text_button__new ("Reset", 0, 6);
  147.  
  148.     time3d_on_gadgetp = radio_button__new ("3D-Time On", 8, 6);
  149.  
  150.     hidden3d_gadgetp = radio_button__new ("Hidden3D", 21, 6);
  151.  
  152. /*    time3d_message_gadgetp = message_gadget__new (40, 0, 7); */
  153.  
  154.     end_time3d_gadgetp = text_button__new ("...Done", 32, 6);
  155.  
  156.     time3d_rp = requester__new ();
  157.     time3d_rp->ReqGadget = end_time3d_gadgetp;
  158.     time3d_rp->ReqText =  NULL;
  159.  
  160.     } /* Ok, time3d_rp has been created */
  161.     
  162.  
  163.     if (requester__display (time3d_rp, dialog_window_p))
  164.     {
  165.     SET_TIME3D_ON;
  166.     if (Hidden3D) radio_button__in (hidden3d_gadgetp, dialog_window_p);
  167.     ActivateGadget (time_segsize_gadgetp,
  168.             dialog_window_p,
  169.             time3d_rp);
  170.     while (TRUE)
  171.     {
  172.         Wait (1 << dialog_window_p->UserPort->mp_SigBit);
  173.         while (message = (struct IntuiMessage *) GetMsg 
  174.            (dialog_window_p->UserPort))
  175.         {
  176.         class = message->Class;
  177.         qualifier = message->Qualifier;
  178.         address = message->IAddress;
  179.         ReplyMsg ((struct Message *) message);
  180.             /*
  181.          * Finish unfinished string
  182.          */
  183.  
  184.         if (string_gadget_being_set &&
  185.             string_gadget_being_set != address &&
  186.             address != (APTR) reset_time3d_gadgetp)
  187.         {
  188.             next_address = address;
  189.             next_class = class;
  190.             next_qualifier = qualifier;
  191.             address = string_gadget_being_set;
  192.             class = IDCMP_GADGETUP;
  193.             qualifier = NULL;
  194.         }
  195.         string_gadget_being_set = NULL;
  196.  
  197.         while (address) /* once for previous string, then next */
  198.         {
  199.             CATCH_ERROR
  200.  
  201.             if (qualifier & IEQUALIFIER_CONTROL)
  202.             {
  203.             help_message ("Workbench 3D-Time Help");
  204.             }
  205.             /*
  206.          * Check for string GADGETDOWN
  207.          */
  208.             else if (class == IDCMP_GADGETDOWN && 
  209.             ((struct Gadget *) address)->GadgetType &
  210.             GTYP_STRGADGET)
  211.             {
  212.             string_gadget_being_set = address;
  213.             }
  214.             else if (address == (APTR) help_time3d_gadgetp)
  215.             {
  216.             help_message ("Workbench 3D-Time Help");
  217.             }
  218.             else if (address == (APTR) end_time3d_gadgetp)
  219.             {
  220.             requester__remove (time3d_rp, dialog_window_p);
  221.             return;
  222.             }
  223.             else if (address == (APTR) time3d_on_gadgetp)
  224.             {
  225.             radio_button__toggle (time3d_on_gadgetp,
  226.                           set_time_3d,
  227.                           set_no_time_3d,
  228.                           dialog_window_p);
  229.             }
  230.             else if (address == (APTR) hidden3d_gadgetp)
  231.             {
  232.             radio_button__toggle (hidden3d_gadgetp,
  233.                           set_hidden_3d,
  234.                           set_no_hidden_3d,
  235.                           dialog_window_p);
  236.             }
  237.             else if (address == (APTR) time_segsize_gadgetp)
  238.             {
  239.             string_gadget__apply 
  240.               (time_segsize_gadgetp, set_time_seg_size);
  241.             if (TimeSegments == NOT_SET)
  242.             {
  243.                 struct StringInfo *sinfop =
  244.                   time_segments_gadgetp->SpecialInfo;
  245.                 char *buffer = sinfop->Buffer;
  246.                 buffer[0] = '\0';
  247.                 refresh_gadget (time_segments_gadgetp,
  248.                         dialog_window_p);
  249.             }
  250.             if (!next_address)
  251.             {
  252.                 ActivateGadget (time_segments_gadgetp,
  253.                         dialog_window_p,
  254.                         time3d_rp);
  255.             }
  256.             }
  257.             else if (address == (APTR) time_segments_gadgetp)
  258.             {
  259.             string_gadget__apply (time_segments_gadgetp, 
  260.                           set_time_segments);
  261.             if (TimeSegSize == NOT_SET)
  262.             {
  263.                 struct StringInfo *sinfop =
  264.                   time_segsize_gadgetp->SpecialInfo;
  265.                 char *buffer = sinfop->Buffer;
  266.                 buffer[0] = '\0';
  267.                 refresh_gadget (time_segsize_gadgetp,
  268.                         dialog_window_p);
  269.             }
  270.             if (!next_address)
  271.             {
  272.                 ActivateGadget (time_offset_gadgetp,
  273.                         dialog_window_p,
  274.                         time3d_rp);
  275.             }
  276.             }
  277.             else if (address == (APTR) time_offset_gadgetp)
  278.             {
  279.             string_gadget__apply (time_offset_gadgetp, 
  280.                           set_time_offset);
  281.             if (TimeOffset != NOT_SET)
  282.             {
  283.                 struct StringInfo *sinfop =
  284.                   time_overlap_gadgetp->SpecialInfo;
  285.                 char *buffer = sinfop->Buffer;
  286.                 buffer[0] = '\0';
  287.                 refresh_gadget (time_overlap_gadgetp,
  288.                         dialog_window_p);
  289.             }
  290.             if (!next_address)
  291.             {
  292.                 ActivateGadget (time_overlap_gadgetp,
  293.                         dialog_window_p,
  294.                         time3d_rp);
  295.             }
  296.             }
  297.             else if (address == (APTR) time_overlap_gadgetp)
  298.             {
  299.             /*
  300.                      * ignore if unchanged from default
  301.              */
  302.                 struct StringInfo *sinfo = 
  303.               time_overlap_gadgetp->SpecialInfo;
  304.             int pos = sinfo->BufferPos;
  305.             char *buffer = sinfo->Buffer;
  306.             
  307.             if (!((pos == 0 && 
  308.                   buffer[0] == '0' &&
  309.                   buffer[1] == '.' &&
  310.                   buffer[2] == '5' &&
  311.                   buffer[3] == '\0') ||
  312.                   (TimeOffset != NOT_SET &&
  313.                    buffer[0] == '\0')))
  314.             {
  315.                 buffer = string_gadget__apply 
  316.                   (time_overlap_gadgetp, set_time_overlap);
  317.                 if (!strlen (buffer))
  318.                 {
  319.                 sprintf (buffer, "%g", TimeOverlap);
  320.                 refresh_gadget (time_overlap_gadgetp,
  321.                         dialog_window_p);
  322.                 }
  323.                 if (TimeOffset == NOT_SET)
  324.                 {
  325.                 struct StringInfo *sinfop =
  326.                   time_offset_gadgetp->SpecialInfo;
  327.                 char *buffer = sinfop->Buffer;
  328.                 buffer[0] = '\0';
  329.                 refresh_gadget (time_offset_gadgetp,
  330.                         dialog_window_p);
  331.                 }
  332.             }
  333.             if (!next_address)
  334.             {
  335.                 ActivateGadget (rotx_gadgetp,
  336.                         dialog_window_p,
  337.                         time3d_rp);
  338.             }
  339.             }
  340.             else if (address == (APTR) reset_time3d_gadgetp ||
  341.                  address == (APTR) set_up_1_gadgetp)
  342.             {
  343.             set_time_offset (NullString);
  344.             set_time_overlap (NullString);
  345.             set_time_segments (NullString);
  346.             set_time_seg_size (NullString);
  347.             set_no_time_3d (NullString);
  348.             set_rotation_x (NullString);
  349.             set_rotation_z (NullString);
  350.             set_no_hidden_3d (NullString);
  351.  
  352.             string_gadget__reset (time_offset_gadgetp,
  353.                           "\0", dialog_window_p);
  354.             string_gadget__reset (time_segments_gadgetp,
  355.                           "\0", dialog_window_p);
  356.             string_gadget__reset (time_segsize_gadgetp,
  357.                           "\0", dialog_window_p);
  358.  
  359.             sprintf (string, "%g", TimeOverlap);
  360.             string_gadget__reset (time_overlap_gadgetp,
  361.                           string, dialog_window_p);
  362.  
  363.             sprintf (string, "%g", RotX);
  364.             string_gadget__reset (rotx_gadgetp,
  365.                           string, dialog_window_p);
  366.  
  367.             sprintf (string, "%g", RotZ);
  368.             string_gadget__reset (rotz_gadgetp,
  369.                           string, dialog_window_p);
  370.  
  371.             radio_button__out (time3d_on_gadgetp,
  372.                        dialog_window_p);
  373.  
  374.             radio_button__out (hidden3d_gadgetp,
  375.                        dialog_window_p);
  376.  
  377.             if (address == (APTR) set_up_1_gadgetp)
  378.             {
  379.                 string_gadget__reset (time_segments_gadgetp,
  380.                           "10", dialog_window_p);
  381.                 set_time_segments ("10");
  382.             }
  383.                        
  384.             }
  385.             else if (address == (APTR) rotx_gadgetp)
  386.             {
  387.             char *buffer =
  388.               string_gadget__apply (rotx_gadgetp,
  389.                         set_rotation_x);
  390.             if (!strlen (buffer))
  391.             {
  392.                 sprintf (string, "%g", RotX);
  393.                 string_gadget__reset (rotx_gadgetp,
  394.                           string, dialog_window_p);
  395.             }
  396.             if (!next_address)
  397.             {
  398.                 ActivateGadget (rotz_gadgetp,
  399.                         dialog_window_p,
  400.                         time3d_rp);
  401.             }
  402.             }
  403.             else if (address == (APTR) rotz_gadgetp)
  404.             {
  405.             char *buffer = 
  406.               string_gadget__apply (rotz_gadgetp,
  407.                         set_rotation_z);
  408.             if (!strlen (buffer))
  409.             {
  410.                 sprintf (string, "%g", RotZ);
  411.                 string_gadget__reset (rotz_gadgetp,
  412.                           string, dialog_window_p);
  413.             }
  414.             if (!next_address)
  415.             {
  416.                 ActivateGadget (time_segsize_gadgetp,
  417.                         dialog_window_p,
  418.                         time3d_rp);
  419.             }
  420.             }
  421.             END_CATCH_ERROR;
  422.             SET_TIME3D_ON;
  423.             address = next_address;
  424.             class = next_class;
  425.             qualifier = next_qualifier;
  426.             next_address = NULL;
  427.             next_class = NULL;
  428.             next_qualifier = NULL;
  429.         } /* while next address */
  430.         }
  431.     }
  432.     }
  433. }
  434.  
  435. #endif /* end ifdef AMIGA */
  436.  
  437.  
  438.  
  439.  
  440.