home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 024.lha / VoiceFiler.c < prev    next >
C/C++ Source or Header  |  1987-04-02  |  18KB  |  668 lines
  1. /*    (C) Copyright 1986 Jack Deckard   Helicon Software    */
  2. /*                                */
  3. /*        DX7 Voice Librarian  by Jack Deckard        */
  4. /*    Simple program to send/recieve 32 voice data files    */
  5. /*    from Yamaha DX synth and load/save them on disk.    */
  6. /*    Special thanks to Michael Mounier, from who's ATERM     */
  7. /*    program I learned to write C code.            */
  8. /*    Use Aztec +l option (32 bit int) when compiling.    */
  9.  
  10. #include <exec/types.h>
  11. #include <exec/exec.h>
  12. #include <intuition/intuition.h>
  13. #include <devices/serial.h>
  14. #include <libraries/dos.h>
  15. #include <libraries/dosextens.h>
  16. #include <stdio.h>
  17.  
  18. #define VERSION 31L    /* 1.1 Library Version    */
  19.  
  20. /* Define all global variables, pointers, structures, etc    */
  21. struct IntuitionBase *IntuitionBase;
  22. struct GfxBase *GfxBase;
  23. struct MsgPort *MRport;
  24. struct MsgPort *MWport;
  25. struct MsgPort *CreatePort();
  26. struct IORequest *CreateExtIO();
  27. struct IOExtSer *IORser;        /* Read serial request block    */
  28. struct IOExtSer *IOWser;        /* Write serial request block    */
  29. struct Window *window;
  30. struct IntuiMessage *NewMessage;
  31. struct Menu menu[2];
  32. struct MenuItem menuitem[6];
  33. struct IntuiText menutext[6];
  34. struct FileHandle *filehandle;        /* Load and save voice files    */
  35. static char name[32];
  36.  
  37. /* Initialize NewWindow structure    */
  38. struct NewWindow newwindow = {
  39.     10,        /* LeftEdge */
  40.     20,        /* TopEdge  */
  41.     300,        /* Width    */
  42.     80,        /* Height   */
  43.     0,        /* DetailPen */
  44.     1,        /* BlockPen */
  45.     CLOSEWINDOW | MENUPICK | VANILLAKEY | ACTIVEWINDOW
  46.      | INACTIVEWINDOW,    /* IDCMPFlags */
  47.     WINDOWCLOSE | SMART_REFRESH | ACTIVATE | WINDOWDRAG | WINDOWDEPTH
  48.      | NOCAREREFRESH,    /* Flags */
  49.     NULL,        /* FirstGadget */
  50.     NULL,        /* CheckMark */
  51.     (UBYTE *) "DX Voice Filer",    /* Title */
  52.     NULL,        /* Screen */
  53.     NULL,        /* BitMap */
  54.     300,        /* MinWidth */
  55.     80,        /* MinHeight */
  56.     300,        /* MaxWidth */
  57.     80,        /* MaxHeight */
  58.     WBENCHSCREEN,    /* Type */
  59.     };
  60.  
  61. SHORT linearray[] = {
  62.     0,20,
  63.     0,79,
  64.     299,79,
  65.     299,14
  66.     };
  67.  
  68.  
  69. main()
  70. {
  71. VOID InitMenu(), ClearWindow();
  72. LONG loadfile(), savefile();
  73. LONG error;
  74. ULONG class;
  75. SHORT KeepGoing;
  76. static USHORT capture, chksum;
  77. USHORT i, code, menunum, itemnum;
  78. static UBYTE rs_in[2];            /* read data    */
  79. UBYTE c[2], voicedata[4104];
  80. voicedata[0] = 0xf0;    /* Status byte        */
  81. voicedata[1] = 0x43;    /* ID (Yamaha)        */
  82. voicedata[2] = 0x00;    /* Substatus & channel    */
  83. voicedata[3] = 0x09;    /* Format #        */
  84. voicedata[4] = 0x20;    /* MSB count        */
  85. voicedata[5] = 0x00;    /* LSB count        */
  86. voicedata[6] = 0x00;    /* 1st data byte    */
  87. voicedata[4101] = 0x00;    /* 4096th data byte    */
  88. voicedata[4102] = 0x00;    /* Check Sum        */
  89. voicedata[4103] = 0xf7; /* EOX            */
  90.  
  91. /*    *    *    *    *    *    *    *    *    */
  92. /*  Open Intuition and Graphics libraries. If error, exit immediatly    */
  93. IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",31L);
  94. if (IntuitionBase == NULL) exit(100L);
  95.  
  96. GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",VERSION);
  97. if (GfxBase == NULL) exit(100L);
  98.  
  99. /* Initialize window struct, then call OpenWindow. Exit if error    */
  100. if ((window = (struct Window *)OpenWindow(&newwindow)) == NULL) exit(100L);
  101.  
  102. /*  Initialize Menu items, then submit them to Intuition        */
  103. InitMenu();
  104. SetMenuStrip(window,&menu);
  105.  
  106. /*    *    *    *    *    *    *    *    *    */
  107. /*  Create the Read serial reply port, and request block        */
  108. MRport = CreatePort(SERIALNAME,0L);
  109. if(MRport == NULL)
  110.     {
  111.     puts("Error during read CreatePort\n");
  112.     ClearMenuStrip(window);
  113.     CloseWindow(window);
  114.     exit(100L);
  115.     }
  116.  
  117. /* Create request block for reading from serial port. IORser is        */
  118. /*  pointer to that request block.                    */
  119. IORser = (struct IOExtSer *)CreateExtIO(MRport,sizeof(struct IOExtSer));
  120. if(IORser == NULL)
  121.     {
  122.     puts("Error during CreateExtIO (read)\n");
  123.     DeletePort(MRport);
  124.     ClearMenuStrip(window);
  125.     CloseWindow(window);
  126.     exit(100L);
  127.     }
  128.  
  129. /* Set initial parms, then open the serial device            */
  130. IORser -> io_SerFlags = SERF_XDISABLED | SERF_SHARED;
  131. if((error = OpenDevice(SERIALNAME,0L,IORser,0L))!=0L)
  132.     {
  133.     puts("Read serial device did not open\n");
  134.     DeletePort(MRport);
  135.     DeleteExtIO(MRport,sizeof(struct IOExtSer));
  136.     ClearMenuStrip(window);
  137.     CloseWindow(window);
  138.     exit(100L);
  139.     }
  140.  
  141. /* Now set all the other serial parms, ie MIDI baud rate, no parity,    */
  142. /*  8 data bits, 1 start bit, 1 stop bit, no break signal        */
  143. IORser -> IOSer.io_Length = 1;
  144. IORser -> IOSer.io_Data = (APTR) &rs_in[0];
  145. IORser -> io_SerFlags = SERF_SHARED | SERF_RAD_BOOGIE;
  146. IORser -> io_Baud = 31250;
  147. IORser -> io_ReadLen = 8;
  148. IORser -> io_WriteLen = 8;
  149. IORser -> io_StopBits = 1;
  150. IORser -> io_RBufLen = 5120;
  151. IORser -> IOSer.io_Command = SDCMD_SETPARAMS;
  152. DoIO(IORser);
  153. IORser -> IOSer.io_Command = CMD_READ;
  154.  
  155. /*    *    *    *    *    *    *    *    *    */
  156. /*  Create the Write serial reply port, and request block        */
  157. MWport = CreatePort(SERIALNAME,0L);
  158. if(MWport == NULL)
  159.     {
  160.     puts("Error during CreatePort (write)\n");
  161.     CloseDevice(IORser);
  162.     DeletePort(MRport);
  163.     ClearMenuStrip(window);
  164.     CloseWindow(window);
  165.     exit(100L);
  166.     }
  167.  
  168. /* Create write request block (IOWser) for passing info.        */
  169. IOWser = (struct IOExtSer *)CreateExtIO(MWport,sizeof(struct IOExtSer));
  170. if(IOWser == NULL)
  171.     {
  172.     puts("Error during CreateExtIO (write)\n");
  173.     DeletePort(MWport);
  174.     CloseDevice(IORser);
  175.     DeletePort(MRport);
  176.     ClearMenuStrip(window);
  177.     CloseWindow(window);
  178.     exit(100L);
  179.     }
  180.  
  181. /* Set initial parms, then open the write serial device            */
  182. IOWser -> io_SerFlags = SERF_XDISABLED | SERF_SHARED;
  183. if((error = OpenDevice(SERIALNAME,0L,IOWser,0L))!=0L)
  184.     {
  185.     puts("Write serial device did not open\n");
  186.     DeletePort (MWport);
  187.     DeleteExtIO(MWport,sizeof(struct IOExtSer));
  188.     CloseDevice(IORser);
  189.     DeletePort(MRport);
  190.     ClearMenuStrip(window);
  191.     CloseWindow(window);
  192.     exit(100L);
  193.     }
  194.  
  195. IOWser -> IOSer.io_Command = CMD_WRITE;
  196. IOWser -> IOSer.io_Length = 4104;
  197. IOWser -> IOSer.io_Data = (APTR) &voicedata[0];
  198.  
  199. /*  Display initial screen message credits    */
  200. Move(window->RPort,20L,20L);
  201. Text(window->RPort,"DX Voice Filer  by Jack Deckard",31L);
  202. Move(window->RPort,20L,28L);
  203. Text(window->RPort,"(C) 1986 Helicon Software",25L);
  204.  
  205. /*  Wait for message at IDCMP port  */
  206. KeepGoing = 1;
  207. capture = 0;
  208. SetAPen(window -> RPort,1L);
  209. BeginIO(IORser);
  210.  
  211. while( KeepGoing )
  212.     {
  213.     /* wait for window message or serial port message */
  214.     Wait((1L << IORser -> IOSer.io_Message.mn_ReplyPort -> mp_SigBit) | 
  215.         ( 1L << window -> UserPort -> mp_SigBit));
  216.     if(CheckIO(IORser))    /* another byte sent to Amiga?    */
  217.         {
  218.         WaitIO(IORser);
  219.         c[0] = rs_in[0];
  220.         BeginIO(IORser);
  221.         if(c[0] > 0x7f)    /* MIDI status byte    */
  222.             {
  223.             capture = 0;
  224.             chksum = 0;
  225.             if(c[0] == 0xf0) ++capture;
  226.             }
  227.         else if(capture)    /* MIDI data byte    */
  228.             {
  229.             if ((capture > 5) && (capture < 4102))
  230.                 {
  231.                 voicedata[capture] = c[0];
  232.                 chksum += c[0];
  233.                 }
  234.             else if (capture == 4102)    
  235.                 {
  236.                 ClearWindow();
  237.                 chksum = 127 & ((~chksum)+1);
  238.                 if (chksum == c[0])
  239.                     {
  240.                     Move(window->RPort,20L,20L);
  241.                     Text(window->RPort,"Gotcha",6L);
  242.                     /* save voicedata to disk    */
  243.                     error = savefile(&voicedata[6]);
  244.                     if (error == 1L)
  245.                         {
  246.                         Move(window->RPort,20L,52L);
  247.                         Text(window->RPort,"Data Saved",10L);
  248.                         }
  249.                     else if (error == 0L)
  250.                         {
  251.                         Move(window->RPort,20L,52L);
  252.                         Text(window->RPort,"I/O ERROR  File not saved",27L);
  253.                         }
  254.                     else if (error == -1L)
  255.                         {
  256.                         Move(window->RPort,20L,52L);
  257.                         Text(window->RPort,"Save Aborted",12L);
  258.                         }
  259.                     }
  260.                 else
  261.                     {
  262.                     Move(window->RPort,20L,52L);
  263.                     Text(window->RPort,"Data Error in Voice File",24L);
  264.                     }
  265.                 }
  266.             ++capture;
  267.             }
  268.         }
  269.     while(NewMessage=(struct IntuiMessage *)GetMsg(window->UserPort) )
  270.         {
  271.         class = NewMessage->Class;
  272.         code = NewMessage->Code;
  273.         ReplyMsg( NewMessage );
  274.         switch( class )
  275.             {
  276.             case VANILLAKEY:
  277.             break;
  278.             case ACTIVEWINDOW:
  279.             break;
  280.             case INACTIVEWINDOW:
  281.             break;
  282.             case CLOSEWINDOW:  /* User is ready to quit, so
  283.                 indicate that execution should terminate with
  284.                 next iteration of the loop. */
  285.                 KeepGoing = 0;
  286.             break;
  287.             case MENUPICK:
  288.                 if ( code != MENUNULL )
  289.                     {
  290.                     menunum = MENUNUM( code );
  291.                     itemnum = ITEMNUM( code );
  292.                     switch(menunum)
  293.                         {
  294.                         case 0:
  295.                             switch( itemnum )
  296.                                 {
  297.                                 case 0:    /* DX to Amiga */
  298.                                     ClearWindow();
  299.                                     Move(window->RPort,20L,20L);
  300.                                     Text(window->RPort,"Send DX data to Amiga  ",23L);
  301.                                     Move(window->RPort,20L,36L);
  302.                                     Text(window->RPort,"Put DX in SYS INFO AVAIL",24L);
  303.                                     Move(window->RPort,20L,44L);
  304.                                     Text(window->RPort,"mode, select MIDI TRANSMIT?",27L);
  305.                                     Move(window->RPort,20L,52L);
  306.                                     Text(window->RPort,"and then press YES",18L);
  307.                                 break;
  308.                                 case 1: /* Amiga to DX */
  309.                                     ClearWindow();
  310.                                     Move(window->RPort,20L,20L);
  311.                                     Text(window->RPort,"Send Amiga data to DX",21L);
  312.                                     /*  Load the file on disk into array voicefile  */
  313.                                     error = loadfile(&voicedata[6]);
  314.                                     if (error == 1L)
  315.                                         {
  316.                                         for (i = 6; i < 4102; ++i)
  317.                                             {
  318.                                             chksum += voicedata[i];
  319.                                             }
  320.                                         /* get 2s complement of chksum    */
  321.                                         voicedata[4102] = (UBYTE)(127 & ((~chksum)+1));
  322.                                         /* send all 4104 bytes to DX    */
  323.                                         DoIO(IOWser);
  324.                                         Move(window->RPort,20L,52L);
  325.                                         Text(window->RPort,"Voice data to DX complete",25L);
  326.                                         }
  327.                                     else if (error == 0L) 
  328.                                         {
  329.                                         Move(window->RPort,20L,52L);
  330.                                         Text(window->RPort,"I/O ERROR  File Not Found",25L);
  331.                                         }
  332.                                     else if (error == -1L) 
  333.                                         {
  334.                                         Move(window->RPort,20L,52L);
  335.                                         Text(window->RPort,"Load Aborted",12L);
  336.                                         }
  337.                                 break;
  338.                                 case 2: /* RND to DX7 */
  339.                                     ClearWindow();
  340.                                     Move(window->RPort,20L,20L);
  341.                                     Text(window->RPort,"Send random data to DX",22L);
  342.                                     /*  generate RND data into array voicefile  */
  343.                                     for (i = 6; i < 4102; ++i)
  344.                                         {
  345.                                         voicedata[i] = RangeRand(127L);
  346.                                         chksum += voicedata[i];
  347.                                         }
  348.                                     /* get 2s complement of chksum    */
  349.                                     voicedata[4102] = (UBYTE)(127 & ((~chksum)+1));
  350.                                     /* send all 4104 bytes to DX    */
  351.                                     DoIO(IOWser);
  352.                                     Move(window->RPort,20L,52L);
  353.                                     Text(window->RPort,"Random data to DX complete",26L);
  354.                                 break;
  355.                                 }
  356.                         break;
  357.                         case 1:
  358.                             switch (itemnum)
  359.                                 {
  360.                                 case 0:    /* DX7    */
  361.                                     voicedata[3] = 0x09;
  362.                                 break;    /* DX21    */
  363.                                 case 1:
  364.                                     voicedata[3] = 0x04;
  365.                                 break;
  366.                                 case 2:    /* DX100    */
  367.                                     voicedata[3] = 0x04;
  368.                                 break;
  369.                                 }
  370.                         break;
  371.                         } /* end of switch ( menunum ) */
  372.                     } /*  end of if ( not null ) */
  373.             break;
  374.             } /* end of switch (class) */
  375.         } /* end of while ( newmessage )*/
  376.     } /* end while ( keepgoing ) */
  377.  
  378. /*    *    *    *    *    *    *    *    *    */
  379. /*   It must be time to quit, so we have to clean            */
  380. /*   up and exit.                            */
  381.  
  382. CloseDevice(IOWser);    /* Close Write serial device    */
  383. DeletePort(MWport);
  384. DeleteExtIO(IOWser,sizeof(struct IOExtSer));
  385. CloseDevice(IORser);    /* Close Read serial device    */
  386. DeletePort(MRport);
  387. DeleteExtIO(IORser,sizeof(struct IOExtSer));
  388. ClearMenuStrip(window);
  389. CloseWindow(window);
  390. exit(FALSE);
  391. }            /* end of main    */
  392.  
  393.  
  394. VOID InitMenu()    /*  Set up Menu    */
  395. {
  396. /* Initialize Menu Header Voice Data Transfer */
  397. menu[0].NextMenu = &menu[1];
  398. menu[0].LeftEdge = 5;
  399. menu[0].TopEdge = 0;
  400. menu[0].Width = 165;
  401. menu[0].Height = 10;
  402. menu[0].Flags = MENUENABLED | MIDRAWN;
  403. menu[0].MenuName = "Voice Data Transfer";
  404. menu[0].FirstItem = &menuitem[0];
  405.  
  406. /* Initialize menu item  "DX to Amiga"  */
  407. menuitem[0].NextItem = &menuitem[1];
  408. menuitem[0].LeftEdge = 0;
  409. menuitem[0].TopEdge = 0;
  410. menuitem[0].Width = 156;
  411. menuitem[0].Height = 11;
  412. menuitem[0].Flags = ITEMTEXT | COMMSEQ | ITEMENABLED | HIGHCOMP;
  413. menuitem[0].MutualExclude = 0xffff;
  414. menuitem[0].ItemFill = (APTR)&menutext[0];
  415. menuitem[0].SelectFill = NULL;
  416. menuitem[0].Command = 'c';
  417. menuitem[0].SubItem = NULL;
  418. menuitem[0].NextSelect = NULL;
  419.  
  420. menutext[0].FrontPen = 0;
  421. menutext[0].BackPen = 1;
  422. menutext[0].DrawMode = JAM2;
  423. menutext[0].LeftEdge = 0;
  424. menutext[0].TopEdge = 1;
  425. menutext[0].ITextFont = NULL;
  426. menutext[0].IText = (UBYTE *) "DX to Amiga";
  427. menutext[0].NextText = NULL;
  428.  
  429. /* Second Menu Item  "Amiga to DX"  */
  430. menuitem[1].NextItem = &menuitem[2];
  431. menuitem[1].LeftEdge = 0;
  432. menuitem[1].TopEdge = 11;
  433. menuitem[1].Width = 156;
  434. menuitem[1].Height = 11;
  435. menuitem[1].Flags = ITEMTEXT | COMMSEQ | ITEMENABLED | HIGHCOMP;
  436. menuitem[1].MutualExclude = 0xffff;
  437. menuitem[1].ItemFill = (APTR) &menutext[1];
  438. menuitem[1].SelectFill = NULL;
  439. menuitem[1].Command = 's';
  440. menuitem[1].SubItem = NULL;
  441. menuitem[1].NextSelect = NULL;
  442.  
  443. menutext[1].FrontPen = 0;
  444. menutext[1].BackPen = 1;
  445. menutext[1].DrawMode = JAM2;
  446. menutext[1].LeftEdge = 0;
  447. menutext[1].TopEdge = 1;
  448. menutext[1].ITextFont = NULL;
  449. menutext[1].IText = (UBYTE *) "Amiga to DX";
  450. menutext[1].NextText = NULL;
  451.  
  452. /* Third Menu Item  "RND to DX"  */
  453. menuitem[2].NextItem = NULL;
  454. menuitem[2].LeftEdge = 0;
  455. menuitem[2].TopEdge = 22;
  456. menuitem[2].Width = 156;
  457. menuitem[2].Height = 11;
  458. menuitem[2].Flags = ITEMTEXT | COMMSEQ | ITEMENABLED | HIGHCOMP;
  459. menuitem[2].MutualExclude = 0xffff;
  460. menuitem[2].ItemFill = (APTR) &menutext[2];
  461. menuitem[2].SelectFill = NULL;
  462. menuitem[2].Command = 'r';
  463. menuitem[2].SubItem = NULL;
  464. menuitem[2].NextSelect = NULL;
  465.  
  466. menutext[2].FrontPen = 0;
  467. menutext[2].BackPen = 1;
  468. menutext[2].DrawMode = JAM2;
  469. menutext[2].LeftEdge = 0;
  470. menutext[2].TopEdge = 1;
  471. menutext[2].ITextFont = NULL;
  472. menutext[2].IText = (UBYTE *) "RND to DX";
  473. menutext[2].NextText = NULL;
  474.  
  475. /* Initialize Menu Header DX Synth */
  476. menu[1].NextMenu = NULL;
  477. menu[1].LeftEdge = 175;
  478. menu[1].TopEdge = 0;
  479. menu[1].Width = 140;
  480. menu[1].Height = 10;
  481. menu[1].Flags = MENUENABLED | MIDRAWN;
  482. menu[1].MenuName = "DX Synthesizer";
  483. menu[1].FirstItem = &menuitem[3];
  484.  
  485. /* Initialize menu item  "DX7"  */
  486. menuitem[3].NextItem = &menuitem[4];
  487. menuitem[3].LeftEdge = 0;
  488. menuitem[3].TopEdge = 0;
  489. menuitem[3].Width = 132;
  490. menuitem[3].Height = 11;
  491. menuitem[3].Flags = CHECKIT | CHECKED | ITEMTEXT | COMMSEQ | ITEMENABLED | HIGHCOMP;
  492. menuitem[3].MutualExclude = 0xfffe;
  493. menuitem[3].ItemFill = (APTR)&menutext[3];
  494. menuitem[3].SelectFill = NULL;
  495. menuitem[3].Command = '7';
  496. menuitem[3].SubItem = NULL;
  497. menuitem[3].NextSelect = NULL;
  498.  
  499. menutext[3].FrontPen = 0;
  500. menutext[3].BackPen = 1;
  501. menutext[3].DrawMode = JAM2;
  502. menutext[3].LeftEdge = CHECKWIDTH;
  503. menutext[3].TopEdge = 1;
  504. menutext[3].ITextFont = NULL;
  505. menutext[3].IText = (UBYTE *) "DX7";
  506. menutext[3].NextText = NULL;
  507.  
  508. /* Second Menu Item  "DX21"  */
  509. menuitem[4].NextItem = &menuitem[5];
  510. menuitem[4].LeftEdge = 0;
  511. menuitem[4].TopEdge = 11;
  512. menuitem[4].Width = 132;
  513. menuitem[4].Height = 11;
  514. menuitem[4].Flags = CHECKIT | ITEMTEXT | COMMSEQ | ITEMENABLED | HIGHCOMP;
  515. menuitem[4].MutualExclude = 0xfffd;
  516. menuitem[4].ItemFill = (APTR) &menutext[4];
  517. menuitem[4].SelectFill = NULL;
  518. menuitem[4].Command = '2';
  519. menuitem[4].SubItem = NULL;
  520. menuitem[4].NextSelect = NULL;
  521.  
  522. menutext[4].FrontPen = 0;
  523. menutext[4].BackPen = 1;
  524. menutext[4].DrawMode = JAM2;
  525. menutext[4].LeftEdge = CHECKWIDTH;
  526. menutext[4].TopEdge = 1;
  527. menutext[4].ITextFont = NULL;
  528. menutext[4].IText = (UBYTE *) "DX21";
  529. menutext[4].NextText = NULL;
  530.  
  531. /* Third Menu Item  "DX100"  */
  532. menuitem[5].NextItem = NULL;
  533. menuitem[5].LeftEdge = 0;
  534. menuitem[5].TopEdge = 22;
  535. menuitem[5].Width = 132;
  536. menuitem[5].Height = 11;
  537. menuitem[5].Flags = CHECKIT | ITEMTEXT | COMMSEQ | ITEMENABLED | HIGHCOMP;
  538. menuitem[5].MutualExclude = 0xfffb;
  539. menuitem[5].ItemFill = (APTR) &menutext[5];
  540. menuitem[5].SelectFill = NULL;
  541. menuitem[5].Command = '1';
  542. menuitem[5].SubItem = NULL;
  543. menuitem[5].NextSelect = NULL;
  544.  
  545. menutext[5].FrontPen = 0;
  546. menutext[5].BackPen = 1;
  547. menutext[5].DrawMode = JAM2;
  548. menutext[5].LeftEdge = CHECKWIDTH;
  549. menutext[5].TopEdge = 1;
  550. menutext[5].ITextFont = NULL;
  551. menutext[5].IText = (UBYTE *) "DX100";
  552. menutext[5].NextText = NULL;
  553. }
  554.  
  555.  
  556. VOID ClearWindow()    /* Clear the window,    */
  557. {
  558. Move(window->RPort,10L,20L);
  559. ClearScreen(window->RPort);
  560. Move(window->RPort,1L,79L);
  561. Draw(window->RPort,1L,20L);
  562. Move(window->RPort,0L,20L);
  563. PolyDraw(window->RPort,4L,&linearray[0]);
  564. Move(window->RPort,298L,14L);
  565. Draw(window->RPort,298L,79L);
  566. }
  567.  
  568.  
  569. /*  Load a file on disk using buffered I/O, 4096 bytes long.      */
  570. /*  Open the disk file, read the array, and close the file  */
  571.  
  572. LONG loadfile(buffer)
  573. UBYTE *buffer;   /*  pointer to byte array voice file    */
  574. {
  575. VOID filename();
  576.  
  577. filename();
  578. if (name[0] == 0) return(-1L);    /* aborted save    */
  579. filehandle = Open(name,MODE_OLDFILE);
  580. if (filehandle == 0L) return(0L);
  581. if(Read(filehandle,buffer,4096L) == -1L)
  582.     {
  583.     Close(filehandle); /* error    */
  584.     return(0L);
  585.     }
  586. Close(filehandle);
  587. return(1L);
  588. }
  589.  
  590.  
  591. /*  Create a file on disk using buffered I/O, 4096 bytes long        */
  592. /*  Open the disk file, write the array to it, and close the file.    */
  593.  
  594. LONG savefile(buffer)
  595. UBYTE *buffer;   /*  pointer to voice file  */
  596. {
  597. VOID filename();
  598.  
  599. filename();
  600. if (name[0] == 0) return(-1L);    /* aborted save    */
  601. filehandle = Open(name,MODE_NEWFILE);
  602. if (filehandle == 0L) return(0L);
  603. if(Write(filehandle,buffer,4096L) == -1L)
  604.     {
  605.     Close(filehandle);    /* error    */
  606.     return(0L);
  607.     }
  608. Close(filehandle);
  609. return(1L);
  610. }
  611.  
  612. /* function to get file name    */
  613. VOID filename()
  614. {
  615. ULONG    class;
  616. USHORT    code,
  617.     keepgoing = 1,
  618.     i = 0;
  619. LONG    x = 100;
  620.  
  621. Move(window->RPort,20L,36L);
  622. Text(window->RPort,"File name? ",11L);
  623.  
  624. while(keepgoing)
  625.     {
  626.     Wait( 1L << window -> UserPort -> mp_SigBit);
  627.     while(NewMessage=(struct IntuiMessage *)GetMsg(window->UserPort))
  628.         {
  629.         class = NewMessage->Class;
  630.         code = NewMessage->Code;
  631.         ReplyMsg(NewMessage);
  632.         if(class = VANILLAKEY)
  633.             {
  634.             if(code)
  635.                 {
  636.                 if(code == 13)    /* return    */
  637.                     {
  638.                     name[i]=0;
  639.                     keepgoing = 0;
  640.                     }
  641.                 if(code == 27)    /* ESC    */
  642.                     {
  643.                     name[0]=0;
  644.                     keepgoing = 0;
  645.                     }
  646.                 else if((code == 8) && (i > 0)) /* backspace    */
  647.                     {
  648.                     i--;
  649.                     name[i] = 0;
  650.                     Move(window->RPort,x,36L);
  651.                     Text(window->RPort," ",1L);
  652.                     Move(window->RPort,x,36L);
  653.                     x=x-8L;
  654.                     }
  655.                 else if(code >= 32)
  656.                     {
  657.                     name[i]=code;
  658.                     Text(window->RPort,&name[i],1L);
  659.                     x=x+8L;
  660.                     i++;
  661.                     }
  662.                 }
  663.             }
  664.         } /* end of new message loop    */
  665.     } /* end of while(keepgoing)    */
  666. } /* end of function */
  667.  
  668. /* end of file */