home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / telecomm / bbs / wwbbs26.lha / WWBBS / Programming / Lib / wwbbs_lib.c
Encoding:
C/C++ Source or Header  |  1995-01-28  |  5.9 KB  |  315 lines
  1. #include <exec/types.h>
  2. #include <exec/exec.h>
  3. #include <libraries/wwbbs.h>
  4. #include <ctype.h>
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8.  
  9. #include <proto/exec.h>
  10. #include <proto/dos.h>
  11. #include <proto/wwbbs.h>
  12.  
  13. BOOL Ask(BYTE *prompt,BOOL def)
  14.     {
  15.         BOOL ret=FALSE,kg=TRUE;
  16.         if(prompt)
  17.             printf("~p\n%s (%s,%s)? ",prompt,(def) ? "[Y]" : "Y",(def) ? "N" : "[N]");
  18.         {
  19.             int c;
  20.             while(kg)
  21.                 {
  22.                     c=getchar();
  23.                     if(c==EOF)
  24.                         break;
  25.                     switch(c)
  26.                         {
  27.                             case '\r':
  28.                                 ret=def;
  29.                                 kg=FALSE;
  30.                                 break;
  31.                             case 'Y':
  32.                             case 'y':
  33.                                 ret=TRUE;
  34.                                 kg=FALSE;
  35.                                 break;
  36.                             case 'N':
  37.                             case 'n':
  38.                                 ret=FALSE;
  39.                                 kg=FALSE;
  40.                                 break;
  41.                         }
  42.                 }
  43.         }
  44.         if(!kg)
  45.             {
  46.                 if(ret)
  47.                     printf("~iYes\n");
  48.                 else
  49.                     printf("~iNo\n");
  50.             }
  51.         return(ret);
  52.     }
  53.  
  54. BOOL GetLine(BYTE *id,BYTE *buff,UWORD length,ULONG flags)
  55.     {
  56.         BOOL ret=FALSE;
  57.         UWORD index=0;
  58.         printf("~i");
  59.         if(flags & GLFLG_Edit)
  60.             {
  61.                 index=strlen(buff);
  62.                 buff[index]=NULL;
  63.                 printf(buff);
  64.             }
  65.         else
  66.             strcpy(buff,"");
  67.         {
  68.             BOOL kg=TRUE;
  69.             int c;
  70.             while(kg)
  71.                 {
  72.                     c=getchar();
  73.                     if(c==EOF)
  74.                         break;
  75.                     switch(c)
  76.                         {
  77.                             case '\b':
  78.                                 if(index)
  79.                                     {
  80.                                         index--;
  81.                                         buff[index]=NULL;
  82.                                         printf("\b \b");
  83.                                     }
  84.                                 break;
  85.                             case '\r':
  86.                                 if( !( !index && (flags & GLFLG_NoEmpty) ) )
  87.                                     {
  88.                                         printf("\n");
  89.                                         if(index)
  90.                                             ret=TRUE;
  91.                                         kg=FALSE;
  92.                                     }
  93.                                 break;
  94.                             default:
  95.                                 if(isprint(c) && index<length)
  96.                                     {
  97.                                         if(flags & GLFLG_Format)
  98.                                             {
  99.                                                 if(isalpha(c))
  100.                                                     {
  101.                                                         if( (index && !isalpha(buff[index-1])) || !index)
  102.                                                             c=toupper(c);
  103.                                                         else
  104.                                                             c=tolower(c);
  105.                                                     }
  106.                                             }
  107.                                         if(flags & GLFLG_ToLower)
  108.                                             {
  109.                                                 if(isalpha(c))
  110.                                                     c=tolower(c);
  111.                                             }
  112.                                         if(flags & GLFLG_ToUpper)
  113.                                             {
  114.                                                 if(isalpha(c))
  115.                                                     c=toupper(c);
  116.                                             }
  117.                                         if(flags & GLFLG_Chars)
  118.                                             {
  119.                                                 if(!isalpha(c))
  120.                                                     c=NULL;
  121.                                             }
  122.                                         if(flags & GLFLG_Digits)
  123.                                             {
  124.                                                 if(!isdigit(c))
  125.                                                     c=NULL;
  126.                                             }
  127.                                         if(flags & GLFLG_NoChars)
  128.                                             {
  129.                                                 if(isalpha(c))
  130.                                                     c=NULL;
  131.                                             }
  132.                                         if(flags & GLFLG_NoDigits)
  133.                                             {
  134.                                                 if(isdigit(c))
  135.                                                     c=NULL;
  136.                                             }
  137.                                         if(flags & GLFLG_NoSpaces)
  138.                                             {
  139.                                                 if(isspace(c))
  140.                                                     c=NULL;
  141.                                             }
  142.                                         if(flags & GLFLG_NoPunct)
  143.                                             {
  144.                                                 if(ispunct(c))
  145.                                                     c=NULL;
  146.                                             }
  147.                                         if(flags & GLFLG_BeginChar)
  148.                                             {
  149.                                                 if(!index && !isalpha(c))
  150.                                                     c=NULL;
  151.                                             }
  152.                                         if(flags & GLFLG_BeginDigit)
  153.                                             {
  154.                                                 if(!index && !isdigit(c))
  155.                                                     c=NULL;
  156.                                             }
  157.                                         if(c)
  158.                                             {
  159.                                                 sprintf(&buff[strlen(buff)],"%c",c);
  160.                                                 index++;
  161.                                                 if(flags & GLFLG_NoEcho)
  162.                                                     printf(".");
  163.                                                 else
  164.                                                     printf("%c",c);
  165.                                             }
  166.                                     }
  167.                                 break;
  168.                         }
  169.                     {
  170.                         BOOL pagereceived=FALSE;
  171.                         GetStatusTags(STTAG_Name,id,STTAG_PageReceived,&pagereceived,TAG_END);
  172.                         if(pagereceived)
  173.                             {
  174.                                 printf("~i%s",buff);
  175.                                 SetStatusTags(STTAG_Name,id,STTAG_PageReceived,FALSE,TAG_END);
  176.                             }
  177.                     }
  178.                 }
  179.         }
  180.         return(ret);
  181.     }
  182.  
  183. void ShowText(BYTE *file)
  184.     {
  185.         BYTE rows[4];
  186.         strcpy(rows,"");
  187.         if(GetVar("ROWS",rows,3,NULL)!=-1)
  188.             {
  189.                 FILE *fp=NULL;
  190.                 BYTE file_node[256];
  191.                 int count=0;
  192.                 printf("~o");
  193.                 {
  194.                     BYTE node[33];
  195.                     strcpy(node,"");
  196.                     if(GetVar("NODE",node,32,NULL)!=-1)
  197.                         {
  198.                             sprintf(file_node,"%s.%s",file,node);
  199.                             fp=fopen(file_node,"r");
  200.                         }
  201.                 }
  202.                 if(fp || (fp=fopen(file,"r")))
  203.                     {
  204.                         BYTE buff[256];
  205.                         while(fgets(buff,255,fp))
  206.                             {
  207.                                 if(WaitForChar(Input(),0))
  208.                                     {
  209.                                         getchar();
  210.                                         break;
  211.                                     }
  212.                                 if(count==atoi(rows)-1)
  213.                                     {
  214.                                         printf("~pMore ([Y],N)? ");
  215.                                         if(!Ask(NULL,TRUE))
  216.                                             break;
  217.                                         printf("~o");
  218.                                         count=0;
  219.                                     }
  220.                                 printf(buff);
  221.                                 count++;
  222.                             }
  223.                         fclose(fp);
  224.                     }
  225.             }
  226.     }
  227.  
  228. BOOL RunEditor(BYTE *filename)
  229.     {
  230.         BOOL ret=FALSE;
  231.         BYTE editor[256];
  232.         strcpy(editor,"");
  233.         if(GetVar("EDITOR",editor,255,NULL)!=-1)
  234.             {
  235.                 if(strlen(editor))
  236.                     {
  237.                         BYTE cmd[256];
  238.                         BOOL insert_filename=FALSE;
  239.                         {
  240.                             char *p;
  241.                             if(p=strchr(editor,'%'))
  242.                                 {
  243.                                     p++;
  244.                                     if(*p=='f')
  245.                                         {
  246.                                             insert_filename=TRUE;
  247.                                             *p='s';
  248.                                         }
  249.                                 }
  250.                         }
  251.                         if(insert_filename)
  252.                             sprintf(cmd,editor,filename);
  253.                         else
  254.                             sprintf(cmd,"%s \"%s\"",editor,filename);
  255.                         printf("~r");
  256.                         SetMode(Input(),0);
  257.                         SystemTags(cmd,TAG_END);
  258.                         SetMode(Input(),1);
  259.                         {
  260.                             FILE *fp;
  261.                             if(fp=fopen(filename,"r"))
  262.                                 {
  263.                                     fclose(fp);
  264.                                     if(Ask("Save message",TRUE))
  265.                                         ret=TRUE;
  266.                                     else
  267.                                         DeleteFile(filename);
  268.                                 }
  269.                         }
  270.                     }
  271.                 else
  272.                     printf("~s\nPlease select an editor first.\n");
  273.             }
  274.         return(ret);
  275.     }
  276.  
  277. BOOL Pager(BYTE *text,UWORD lines)
  278.     {
  279.         BOOL ret=FALSE;
  280.         BYTE rows[4];
  281.         strcpy(rows,"");
  282.         if(GetVar("ROWS",rows,3,NULL)!=-1)
  283.             {
  284.                 char *p,*q;
  285.                 int count=0;
  286.                 p=text;
  287.                 count=lines;
  288.                 printf("~o");
  289.                 while(q=strchr(p,'\n'))
  290.                     {
  291.                         if(WaitForChar(Input(),0))
  292.                             {
  293.                                 int c;
  294.                                 c=getchar();
  295.                                 if(c=='\r')
  296.                                     ret=TRUE;
  297.                                 break;
  298.                             }
  299.                         if(count==atoi(rows)-1)
  300.                             {
  301.                                 printf("~pMore ([Y],N)? ");
  302.                                 if(!Ask(NULL,TRUE))
  303.                                     break;
  304.                                 printf("~o");
  305.                                 count=0;
  306.                             }
  307.                         q++;
  308.                         printf("%.*s",q-p,p);
  309.                         p=q;
  310.                         count++;
  311.                     }
  312.             }
  313.         return(ret);
  314.     }
  315.