home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / rsyssrc.lha / RSysExtern.c < prev    next >
C/C++ Source or Header  |  1993-09-23  |  9KB  |  397 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *      RSysExtern.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    BPTR AskFileMode ( char *filename , struct Window *wind );
  12. *    int GetFile ( struct Window *wind , char *dir , char *file , char *pattern , char *title , char *oktext );
  13. *    int InitSpeech ( void );
  14. *    int SysStarted ( int type );
  15. *    void RemoveSpeech ( void );
  16. *    void SaveList ( struct Window *wind , char *filename , char *title , struct List *list , int withheader );
  17. *    void Speak ( char *text );
  18. *
  19. *      --- Lokale  Routinen ---
  20. *
  21. *    static char *strip ( char *src , char *dest );
  22. *
  23. * Bemerkungen:
  24. *      Verwaltung externer Daten und Schnittstellen zu Dateien.
  25. *
  26. * Erstellungsdatum:
  27. *      07-Jul-93     Rolf Böhme
  28. *
  29. * Änderungen:
  30. *      07-Jul-93     Rolf Böhme      Erstellung
  31. *
  32. ***************************************************************************
  33. */
  34.  
  35. #include "RSys.h"
  36.  
  37. char _file[PATHPARTWIDTH],_dir[MAXFULLNAME];
  38.  
  39. static char *
  40. strip(char *src, char *dest)
  41. {
  42.     BYTE s = 0, d = 0, l = strlen(src);
  43.  
  44.     while(s < l)
  45.     {
  46.         if(!strchr("'-:/ ", (int)src[s])) dest[d++] = src[s++];
  47.         else
  48.             s++;
  49.     }
  50.  
  51.     dest[d] = STRINGEND;
  52.  
  53.     return dest;
  54. }
  55.  
  56.  
  57.     /*
  58.      * GetFile() bietet einen Filerequester zur Auswahl einer Datei
  59.      * an. Dabei wird unterschieden, ob die Datei zum Sichern oder zum
  60.      * Laden verwendet wird.
  61.      */
  62. int
  63. GetFile(struct Window *wind,char *dir,char *file,char *pattern,char *title,char *oktext)
  64. {
  65.     struct FileRequester *AslFileRequest = NULL;
  66.     BYTE    Result = FALSE;
  67.     APTR    req = NULL;
  68.     UWORD l = 20,t = 20;
  69.     int mask = FILF_PATGAD;
  70.     char _oktext[MAXSHOW],_title[40],_pattern[10] = "#?",*_cancel = "Cancel";
  71.  
  72.     DPOS;
  73.  
  74.     PrintInfo("Selecting file", NO_SPEAK, 0);
  75.  
  76.     if (Flags.speakmode) Speak(title);
  77.  
  78.     if (AslBase = OpenLibrary((UBYTE *) "asl.library", 37L))
  79.     {
  80.         if(wind)
  81.         {
  82.             req = LockWindow(wind);
  83.             CenterWindow(wind->WScreen,&t,&l,(UWORD)260,(UWORD)170);
  84.         }
  85.  
  86.         if(dir && *dir) strncpy(_dir,dir,MAXFULLNAME);
  87.         else
  88.             strcpy(_dir,"RAM:");
  89.  
  90.         if(file && *file)
  91.         {
  92.             char header[PATHPARTWIDTH];
  93.  
  94.             strip(file, header);
  95.  
  96.             strncpy(_file,header,PATHPARTWIDTH);
  97.         }
  98.         else strcpy(_file,"unknown");
  99.  
  100.         if(pattern && *pattern) strncpy(_pattern,pattern,10);
  101.         else
  102.             strcpy(_pattern,"#?");
  103.  
  104.         if(title && *title) strncpy(_title,title,40);
  105.         else
  106.             strcpy(_title,"Select file");
  107.  
  108.         if(oktext && *oktext) strncpy(_oktext,oktext,MAXSHOW);
  109.         else
  110.             strcpy(_oktext,"Select");
  111.  
  112.         if(strstr(_oktext,"Save")) mask |= FILF_SAVE;
  113.  
  114.         if (AslFileRequest = AllocAslRequestTags(ASL_FileRequest,
  115.                                         ASL_Window,      (ULONG)wind,
  116.                                         ASL_Hail,         (ULONG)_title,
  117.                                         ASL_LeftEdge,     (ULONG)l,
  118.                                         ASL_TopEdge,     (ULONG)t,
  119.                                         ASL_OKText,      (ULONG)_oktext,
  120.                                         ASL_CancelText, (ULONG)_cancel,
  121.                                         ASL_File,         (ULONG)_file,
  122.                                         ASL_Dir,          (ULONG)_dir,
  123.                                         ASL_Pattern,     (ULONG)_pattern,
  124.                                         ASL_FuncFlags,  (ULONG)mask,
  125.                                         TAG_DONE))
  126.         {
  127.             if (AslRequest(AslFileRequest, NULL))
  128.             {
  129.                 if (AslFileRequest->rf_File)
  130.                 {
  131.                strncpy(_fullpath,AslFileRequest->rf_Dir,MAXFULLNAME);
  132.                     AddPart((UBYTE *)_fullpath,(UBYTE *)AslFileRequest->rf_File, MAXFULLNAME);
  133. /*
  134.                     if(AslFileRequest->rf_Dir)
  135.                     {
  136.                         strncpy(_fullpath,AslFileRequest->rf_Dir,MAXFULLNAME);
  137.                         AddPart((UBYTE *)_fullpath,(UBYTE *)AslFileRequest->rf_File,
  138.                                   MAXFULLNAME);
  139.                     }
  140.                     else strncpy(_fullpath,AslFileRequest->rf_File,MAXFULLNAME);
  141. */
  142.                     Result = TRUE;
  143.                 }
  144.  
  145.                 if(AslFileRequest->rf_Pat) strncpy(_pattern,AslFileRequest->rf_Pat,10);
  146.             }
  147.  
  148.             FreeAslRequest(AslFileRequest);
  149.         }
  150.         else ErrorHandle("AllocAslRequest()", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  151.  
  152.         CloseLibrary(AslBase);
  153.  
  154.         UnlockWindow(req);
  155.     }
  156.     else ErrorHandle("asl.library", LIBRARY_ERR, OPEN_FAIL, NO_KILL);
  157.  
  158.     if (strcmp(_oktext, "Check")) PrintStatistics();
  159.  
  160.     return Result;
  161. }
  162.  
  163.  
  164. BPTR
  165. AskFileMode(char *filename, struct Window *wind)
  166. {
  167.    int mode = OVERWRITE;
  168.    BPTR fout = NULL;
  169.  
  170.    if(exist(filename)) mode = MyEasyRequest(wind, (UBYTE *) NAME " ask you",
  171.                                             (UBYTE *) "Append|Overwrite|Cancel",
  172.                                             (UBYTE *) "The file <%s> exists!",
  173.                                             filename);
  174.  
  175.     switch (mode)
  176.     {
  177.         case APPEND:
  178.             fout = Open((UBYTE *) filename, MODE_OLDFILE);
  179.             if(fout) Seek(fout, 0L, OFFSET_END);
  180.             break;
  181.  
  182.         case OVERWRITE:
  183.             fout = Open((UBYTE *) filename, MODE_NEWFILE);
  184.             break;
  185.     }
  186.  
  187.    if(mode && !fout) ErrorHandle(filename, FILE_ERR, OPEN_FAIL, NO_KILL);
  188.  
  189.    return fout;
  190. }
  191.  
  192.     /*
  193.      * SaveList() speichert die Einträge einer Liste (vom Hauptfenster oder
  194.      * intern) in eine Datei ab oder direkt ins Clipboard.
  195.      */
  196. void
  197. SaveList(struct Window *wind, char *filename, char *title,
  198.             struct List *list, int withheader)
  199. {
  200.     BPTR    fout;
  201.     struct Node *node;
  202.     char    out[MAXWRITESIZE], fmt[MAXWRITESIZE];
  203.     int noheader;
  204.  
  205.     DPOS;
  206.  
  207.     PrintInfo("Save list to file", NO_SPEAK, 0);
  208.  
  209.    fout = AskFileMode(filename, wind);
  210.  
  211.     if (fout)
  212.     {
  213.         noheader = RSysFormatOutput(wind, fmt);
  214.  
  215.         if(!noheader)
  216.         {
  217.             sprintf(out, "----------------------------------------------\n"
  218.                       "%s\n"
  219.                       "----------------------------------------------\n\n",
  220.                       title);
  221.  
  222.             Write(fout, out, strlen(out));
  223.  
  224.             if (withheader)
  225.             {
  226.                 sprintf(out, "%s\n----------------------------------------------\n",
  227.                           EntryAttr[LastID].ea_header);
  228.                 Write(fout, out, strlen(out));
  229.             }
  230.         }
  231.  
  232.         for (node = list->lh_Head; node->ln_Succ /*&& !IoErr()*/;
  233.               node = node->ln_Succ)
  234.         {
  235.             sprintf(out, fmt, node->ln_Name);
  236.             strcat((char *)out,"\n");
  237.  
  238.             Write(fout, out, strlen(out));
  239.         }
  240.  
  241.         if (IoErr()) ErrorHandle(filename, FILE_ERR, WRITE_FAIL, NO_KILL);
  242.         else
  243.         {
  244.             Write(fout, (UBYTE *)"\n",1);
  245.          PrintInfo("List was written to file", SPEAK, SEC);
  246.         }
  247.  
  248.         Close(fout);
  249.     }
  250.  
  251.     PrintStatistics();
  252.  
  253.     return;
  254. }
  255.  
  256.     /*
  257.      * SysStarted() überprüft, ob RSys ein zweites Mal gestartet wurde
  258.      * und sendet im zutreffenden Fall einen Argumenttyp der Art der
  259.      * anzuzeigenden Liste an den Task des zuerst gestarteten Programmes
  260.      */
  261. int
  262. SysStarted(int type)
  263. {
  264.     struct MsgPort *TestPort;
  265.     struct MsgPort *ReplyPort = NULL;
  266.     SysMsg *mess;
  267.     int    ret = FALSE;
  268.  
  269.     DPOS;
  270.  
  271.    ReplyPort = CreatePort((UBYTE *) "RSys-Reply-Port", 0L);
  272.  
  273.     if (ReplyPort)
  274.     {
  275.         mess = (SysMsg *) MyAllocVec(sizeof(SysMsg), MEMF_CLEAR | MEMF_PUBLIC, NO_KILL);
  276.  
  277.         if (mess)
  278.         {
  279.             mess->sm_message.mn_Node.ln_Type = NT_MESSAGE;
  280.             mess->sm_message.mn_ReplyPort = ReplyPort;
  281.             mess->sm_message.mn_Length = sizeof(SysMsg);
  282.             mess->sm_newtype = type;
  283.  
  284.             Forbid();
  285.  
  286.             if (TestPort = FindPort((UBYTE *) ID_PORT_NAME))
  287.             {
  288.                 PutMsg(TestPort, (struct Message *) mess);
  289.  
  290.                Permit();
  291.  
  292.                 WaitPort(ReplyPort);
  293.  
  294.                 ret = TRUE;
  295.             }
  296.          else Permit();
  297.  
  298.             MyFreeVec(mess);
  299.         }
  300.  
  301.         DeletePort(ReplyPort);
  302.     }
  303.  
  304.     return ret;
  305. }
  306.  
  307. struct Library *TranslatorBase = NULL;
  308. struct MsgPort *narratorPort;
  309. struct narrator_rb request;
  310.  
  311.     /*
  312.      * RemoveSpeech() entfernt die Ressourcen für die Sprachausgabe
  313.      * und schließt das Device, das für die Sprachausgabe des Amigas
  314.      * zuständig ist, das narrator.device
  315.      */
  316. void
  317. RemoveSpeech(void)
  318. {
  319.     DPOS;
  320.  
  321.     if (narratorPort) DeleteMsgPort(narratorPort);
  322.     if (TranslatorBase) CloseLibrary(TranslatorBase);
  323.     if (request.message.io_Device) CloseDevice((struct IORequest *) &request);
  324.  
  325.     return;
  326. }
  327.  
  328.     /*
  329.      * InitSpeech() öffnet die Ressourcen für die Sprachausgabe
  330.      * Anm: Auf einem 4000er stürzt an dieser Stelle das Programm ab!
  331.      */
  332. int
  333. InitSpeech(void)
  334. {
  335.     DPOS;
  336.  
  337.     if (TranslatorBase = OpenLibrary((UBYTE *) "translator.library", 0))
  338.    {
  339.         if (narratorPort = CreateMsgPort())
  340.         {
  341.             if (NOT(OpenDevice((UBYTE *) "narrator.device", 0,(struct IORequest *) & request, 0)))
  342.                 return (TRUE);
  343.             else
  344.                 ErrorHandle("narrator.device", DEVICE_ERR, OPEN_FAIL, NO_KILL);
  345.         }
  346.         else ErrorHandle("CreateMsgPort()", PORT_ERR, CREATE_FAIL, NO_KILL);
  347.    }
  348.     else ErrorHandle("translator.library", LIBRARY_ERR, OPEN_FAIL, NO_KILL);
  349.  
  350.     RemoveSpeech();
  351.  
  352.     return FALSE;
  353. }
  354.  
  355.     /*
  356.      * Speak() gibt einen Text über das narrator.device aus
  357.      */
  358. void
  359. Speak(char *text)
  360. {
  361.     UBYTE help[BUFSIZE + 2];
  362.     UBYTE translate[3 * BUFSIZE];
  363.     UBYTE Channel[4] = { 1, 2, 4, 8 };
  364.  
  365.     DPOS;
  366.  
  367.    if(!Flags.speakmode)
  368.  
  369.     strncpy((char *)help, text, BUFSIZE);
  370.  
  371.     if (!ispunct((int)text[strlen(text) - 1])) strcat((char *)help, ".");
  372.  
  373.     if (NOT(Translate(help, (strlen((char *)help) * sizeof(char)), translate, sizeof(translate))))
  374.     {
  375.         request.message.io_Message.mn_ReplyPort = narratorPort;
  376.         request.message.io_Command = CMD_WRITE;
  377.         request.message.io_Data = (APTR) translate;
  378.         request.message.io_Length = sizeof(translate);
  379.  
  380.         request.rate            = DEFRATE;  /* Worte pro Minute: 40 < rate < 400 */
  381.         request.pitch            = DEFPITCH; /* 65 < pitch < 320 */
  382.         request.sex             = DEFSEX;   /* Geschlecht : auch MALE */
  383.         request.volume         = DEFVOL;   /* Lautstaerke max 64 */
  384.         request.mode            = DEFMODE;  /* Aussprache-Modus */
  385.         request.sampfreq        = DEFFREQ;
  386.         request.F0enthusiasm = DEFF0ENTHUS;
  387.         request.F0perturb     = DEFF0PERT;
  388.         request.priority        = DEFPRIORITY;
  389.         request.ch_masks        = (UBYTE *) Channel; /* Kanaele */
  390.         request.nm_masks        = sizeof(Channel);
  391.  
  392.         DoIO((struct IORequest *) &request);
  393.     }
  394.  
  395.     return;
  396. }
  397.