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