home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / ftp.vapor.com / microdot-1 / md1_src_02.lzx / md_rexx_rxif.c < prev    next >
C/C++ Source or Header  |  2014-05-19  |  25KB  |  1,218 lines
  1. /*
  2.  * Source generated with ARexxBox 1.13 (Dec  4 1993)
  3.  * which is Copyright (c) 1992,1993 Michael Balzer
  4.  */
  5.  
  6. #include <exec/types.h>
  7. #include <exec/memory.h>
  8. #include <dos/dos.h>
  9. #include <rexx/storage.h>
  10. #include <rexx/rxslib.h>
  11.  
  12. #ifdef __GNUC__
  13. /* GCC needs all struct defs */
  14. #include <dos/exall.h>
  15. #include <graphics/graphint.h>
  16. #include <intuition/classes.h>
  17. #include <devices/keymap.h>
  18. #include <exec/semaphores.h>
  19. #endif
  20.  
  21. #include <clib/alib_protos.h>
  22. #include <clib/exec_protos.h>
  23. #include <clib/dos_protos.h>
  24. #include <clib/rexxsyslib_protos.h>
  25.  
  26. #ifndef __NO_PRAGMAS
  27.  
  28. #ifdef AZTEC_C
  29. #include <pragmas/exec_lib.h>
  30. #include <pragmas/dos_lib.h>
  31. #include <pragmas/rexxsyslib_lib.h>
  32. #endif
  33.  
  34. #ifdef LATTICE
  35. #include <pragmas/exec_pragmas.h>
  36. #include <pragmas/dos_pragmas.h>
  37. #include <pragmas/rexxsyslib_pragmas.h>
  38. #endif
  39.  
  40. #endif /* __NO_PRAGMAS */
  41.  
  42. #include <stdlib.h>
  43. #include <stdio.h>
  44. #include <string.h>
  45. #include <ctype.h>
  46.  
  47. #ifdef LATTICE
  48. #define inline __inline
  49. #endif
  50.  
  51. #ifdef __GNUC__
  52. #undef toupper
  53. static inline char toupper( char c )
  54. {
  55.     return( islower(c) ? c - 'a' + 'A' : c );
  56. }
  57. #endif
  58.  
  59. #ifdef AZTEC_C
  60. #define inline
  61. #endif
  62.  
  63. #include "md_rexx.h"
  64.  
  65.  
  66. extern struct ExecBase *SysBase;
  67. extern struct DosLibrary *DOSBase;
  68. extern struct RxsLib *RexxSysBase;
  69.  
  70.  
  71. /* $ARB: I 754885886 */
  72.  
  73.  
  74. /* $ARB: B 1 GETMODE */
  75.  
  76. #include "microdot.h"
  77.  
  78. void rx_getmode( struct RexxHost *host, struct rxd_getmode **rxd, long action, struct RexxMsg *rexxmsg )
  79. {
  80.     struct rxd_getmode *rd = *rxd;
  81.  
  82.     switch( action )
  83.     {
  84.         case RXIF_INIT:
  85.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  86.             break;
  87.             
  88.         case RXIF_ACTION:
  89.             /* Insert your CODE here */
  90.             rd->rc2 = rexxmode;
  91.             rd->res.mode = &rexxmode;
  92.             rd->rc = 0;
  93.             break;
  94.         
  95.         case RXIF_FREE:
  96.             /* FREE your local data here */
  97.             FreeVec( rd );
  98.             break;
  99.     }
  100.     return;
  101. }
  102. /* $ARB: E 1 GETMODE */
  103.  
  104. /* $ARB: B 2 GETCURRENTMAILHEADER */
  105. void rx_getcurrentmailheader( struct RexxHost *host, struct rxd_getcurrentmailheader **rxd, long action, struct RexxMsg *rexxmsg )
  106. {
  107.     struct rxd_getcurrentmailheader *rd = *rxd;
  108.  
  109.     switch( action )
  110.     {
  111.         case RXIF_INIT:
  112.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  113.             if( rd = *rxd )
  114.             {
  115.                 /* set your DEFAULTS here */
  116.             }
  117.             break;
  118.             
  119.         case RXIF_ACTION:
  120.             if( ( rexxmode != 1 ) && ( rexxmode != 2 ) )
  121.             {
  122.                 rd->rc = -10;
  123.                 rd->rc2 = (ULONG) "Illegal mode";
  124.                 break;
  125.             }
  126.             else
  127.             {
  128.                 struct header *hl;
  129.                 struct hlist *hlist;
  130.                 struct msghandle *msg;
  131.                 int count;
  132.  
  133.                 msg = opencurrentmail();
  134.  
  135.                 if( msg )
  136.                 {
  137.                     hlist = msg_loadheader( msg );
  138.                     hl = hl_findheader( hlist, rd->arg.header );
  139.                     count = rd->arg.index ? *rd->arg.index : 0;
  140.                     while( hl && count-- )
  141.                         hl = hl_findnextheader( hl );
  142.                     if( hl )
  143.                     {
  144.                         rd->rc = 0;
  145.                         rd->rc2 = NULL;
  146.                         rd->res.data = StrDup( host, hl->data );
  147.                     }
  148.                     else
  149.                     {
  150.                         rd->rc = 10;
  151.                         rd->rc2 = ERROR_NO_MORE_ENTRIES;
  152.                     }
  153.                     hl_freeheader( hlist );
  154.                     msg_close( msg );
  155.  
  156.                     break;
  157.                 }
  158.             }
  159.             rd->rc = -10;
  160.             rd->rc = (ULONG) "no current mail";
  161.             break;
  162.         
  163.         case RXIF_FREE:
  164.             /* FREE your local data here */
  165.             FreeVec( rd );
  166.             break;
  167.     }
  168.     return;
  169. }
  170. /* $ARB: E 2 GETCURRENTMAILHEADER */
  171.  
  172. /* $ARB: B 8 HELP */
  173. void rx_help( struct RexxHost *host, struct rxd_help **rxd, long action, struct RexxMsg *rexxmsg )
  174. {
  175.     struct rxd_help *rd = *rxd;
  176.     struct rxs_command *rxc;
  177.  
  178.     /*
  179.      * Dieser HELP-Befehl unterstⁿtzt (noch) nicht das PROMPT-Keyword
  180.      * da das nur im Rahmen eines GUIs Sinn hat
  181.      */
  182.  
  183.     switch( action )
  184.     {
  185.         case RXIF_INIT:
  186.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  187.             break;
  188.             
  189.         case RXIF_ACTION:
  190.             /* Insert your code HERE */
  191.             
  192.             if( rd->arg.prompt )
  193.             {
  194.                 rd->rc = 0;
  195.                 rd->rc2 = 0;
  196.                 showguide( "arexx_commands" );
  197.                 return;
  198.             }
  199.             
  200.             if( rd->arg.command )
  201.             {
  202.                 rxc = FindRXCommand( rd->arg.command );
  203.                 if( !rxc )
  204.                 {
  205.                     rd->rc = -10;
  206.                     rd->rc2 = (long) "Unknown Command";
  207.                     return;
  208.                 }
  209.  
  210.                 if( ( rd->res.commanddesc = AllocVec( strlen( rxc->command )
  211.                     + (rxc->args    ? strlen(rxc->args)    : 0)
  212.                     + (rxc->results ? strlen(rxc->results) : 0) + 42,
  213.                     MEMF_ANY) ) )
  214.                 {
  215.                     sprintf( rd->res.commanddesc,
  216.                         "%s%lc%s%s%s%s%s",
  217.                         rxc->command, 
  218.                         (rxc->results || rxc->args) ? ' ' : '\0',
  219.                         rxc->results ? "VAR/K,STEM/K" : "",
  220.                         (rxc->results && rxc->args) ? "," : "",
  221.                         rxc->args ? rxc->args : "",
  222.                         rxc->results ? " => " : "",
  223.                         rxc->results ? rxc->results : "" );
  224.                 }
  225.                 else
  226.                 {
  227.                     rd->rc = 10;
  228.                     rd->rc2 = ERROR_NO_FREE_STORE;
  229.                     return;
  230.                 }
  231.             }
  232.             else
  233.             {
  234.                 char **s;
  235.                 
  236.                 if( !(s = AllocVec(sizeof(char *) * ( command_cnt + 1 ), MEMF_CLEAR)) )
  237.                 {
  238.                     rd->rc = 10;
  239.                     rd->rc2 = ERROR_NO_FREE_STORE;
  240.                     return;
  241.                 }
  242.                 rd->res.commandlist = s;
  243.                 
  244.                 rxc = rxs_commandlist;
  245.                 while( rxc->command )
  246.                 {
  247.                     *s = rxc->command;
  248.                     s++;
  249.                     rxc++;
  250.                 }
  251.             }
  252.             
  253.             break;
  254.         
  255.         case RXIF_FREE:
  256.             /* FREE your local data HERE */
  257.             
  258.             if( rd->res.commanddesc )
  259.                 FreeVec( rd->res.commanddesc );
  260.             if( rd->res.commandlist )
  261.                 FreeVec( rd->res.commandlist );
  262.             
  263.             FreeVec( rd );
  264.             break;
  265.     }
  266.     return;
  267. }
  268. /* $ARB: E 8 HELP */
  269.  
  270. /* $ARB: B 9 RX */
  271. void rx_rx( struct RexxHost *host, struct rxd_rx **rxd, long action, struct RexxMsg *rexxmsg )
  272. {
  273.     struct {
  274.         struct rxd_rx rd;
  275.         long rc;
  276.     } *rd = (void *) *rxd;
  277.     
  278.     BPTR fh = NULL;
  279.     struct RexxMsg *sentrm;
  280.  
  281.     switch( action )
  282.     {
  283.         case RXIF_INIT:
  284.             *rxd = ARBAlloc( host, sizeof *rd );
  285.             break;
  286.             
  287.         case RXIF_ACTION:
  288.             /* Insert your code HERE */
  289.             
  290.             /* Kommando leer? */
  291.             if( !rd->rd.arg.command )
  292.                 return;
  293.             
  294.             /* Mit Ein-/Ausgabe-Fenster? */
  295.             if( rd->rd.arg.console )
  296.             {
  297.                 fh = OpenCon( "CON:////RX Window/AUTO" );
  298.                 if( !fh )
  299.                 {
  300.                     rd->rd.rc = -20;
  301.                     rd->rd.rc2 = (long) "RX can't open Window";
  302.                     return;
  303.                 }
  304.             }
  305.             
  306.             /* Kommando abschicken */
  307.             if( !(sentrm = SendRexxCommand(host, rd->rd.arg.command, fh)) )
  308.             {
  309.                 rd->rd.rc = -20;
  310.                 rd->rd.rc2 = (long) "RX can't send ARexx command";
  311.                 return;
  312.             }
  313.             
  314.             /* auf den Reply warten */
  315.             if( !rd->rd.arg.async )
  316.             {
  317.                 struct RexxMsg *rm;
  318.                 int waiting = TRUE;
  319.                 
  320.                 do
  321.                 {
  322.                     WaitPort( host->port );
  323.                     
  324.                     while( rm = (struct RexxMsg *) GetMsg(host->port) )
  325.                     {
  326.                         /* Reply? */
  327.                         if( rm->rm_Node.mn_Node.ln_Type == NT_REPLYMSG )
  328.                         {
  329.                             /* 'unsere' Msg? */
  330.                             if( rm == sentrm )
  331.                             {
  332.                                 rd->rc = rm->rm_Result1;
  333.                                 rd->rd.res.rc = &rd->rc;
  334.                                 
  335.                                 if( !rm->rm_Result1 && rm->rm_Result2 )
  336.                                 {
  337.                                     /* Res2 ist String */
  338.                                     rd->rd.res.result =
  339.                                         StrDup( host, (char *) rm->rm_Result2 );
  340.                                 }
  341.                                 
  342.                                 waiting = FALSE;
  343.                             }
  344.                             
  345.                             FreeRexxCommand( rm );
  346.                             --host->replies;
  347.                         }
  348.                         
  349.                         /* sonst Kommando -> Fehler */
  350.                         else if( ARG0(rm) )
  351.                         {
  352.                             ReplyRexxCommand( rm, -20, (long)
  353.                                 "CommandShell Port", NULL );
  354.                         }
  355.                     }
  356.                 }
  357.                 while( waiting );
  358.             }
  359.             
  360.             break;
  361.         
  362.         case RXIF_FREE:
  363.             /* FREE your local data HERE */
  364.             if( rd->rd.res.result ) ARBFree( host, rd->rd.res.result );
  365.             ARBFree( host, rd );
  366.             break;
  367.     }
  368.     return;
  369. }
  370. /* $ARB: E 9 RX */
  371.  
  372. /* $ARB: B 10 EXTRACTCURRENTMAIL */
  373. void rx_extractcurrentmail( struct RexxHost *host, struct rxd_extractcurrentmail **rxd, long action, struct RexxMsg *rexxmsg )
  374. {
  375.     struct rxd_extractcurrentmail *rd = *rxd;
  376.  
  377.     switch( action )
  378.     {
  379.         case RXIF_INIT:
  380.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  381.             if( rd = *rxd )
  382.             {
  383.                 /* set your DEFAULTS here */
  384.             }
  385.             break;
  386.             
  387.         case RXIF_ACTION:
  388.             if( ( rexxmode != 1 ) && ( rexxmode != 2 ) )
  389.             {
  390.                 rd->rc = -10;
  391.                 rd->rc2 = (ULONG) "Illegal mode";
  392.                 break;
  393.             }
  394.             else
  395.             {
  396.                 struct msghandle *msg;
  397.                 int what = MC_DATA;
  398.  
  399.                 if( rd->arg.header )
  400.                     what |= MC_HEADER;
  401.                 if( rd->arg.comment )
  402.                     what |= MC_COMMENT;
  403.  
  404.                 msg = opencurrentmail();
  405.  
  406.                 if( msg )
  407.                 {
  408.                     msg_copy( msg, rd->arg.file, what );
  409.                     rd->rc = 0;
  410.                     rd->rc2 = 0;
  411.  
  412.                     msg_close( msg );
  413.  
  414.                     break;
  415.                 }
  416.             }
  417.             /* Insert your CODE here */
  418.             rd->rc = -10;
  419.             rd->rc = (ULONG) "no current mail";
  420.             break;
  421.         
  422.         case RXIF_FREE:
  423.             /* FREE your local data here */
  424.             FreeVec( rd );
  425.             break;
  426.     }
  427.     return;
  428. }
  429. /* $ARB: E 10 EXTRACTCURRENTMAIL */
  430.  
  431. /* $ARB: B 11 MDVERSION */
  432. void rx_mdversion( struct RexxHost *host, struct rxd_mdversion **rxd, long action, struct RexxMsg *rexxmsg )
  433. {
  434.     struct rxd_mdversion *rd = *rxd;
  435.  
  436.     switch( action )
  437.     {
  438.         case RXIF_INIT:
  439.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  440.             break;
  441.             
  442.         case RXIF_ACTION:
  443.             /* Insert your CODE here */
  444.             rd->rc = 0;
  445.             rd->rc2 = MDUPDVER;
  446.             rd->res.version = MDVER;
  447.             break;
  448.         
  449.         case RXIF_FREE:
  450.             /* FREE your local data here */
  451.             FreeVec( rd );
  452.             break;
  453.     }
  454.     return;
  455. }
  456. /* $ARB: E 11 MDVERSION */
  457.  
  458. /* $ARB: B 12 GETMDPUBSCREENNAME */
  459. void rx_getmdpubscreenname( struct RexxHost *host, struct rxd_getmdpubscreenname **rxd, long action, struct RexxMsg *rexxmsg )
  460. {
  461.     struct rxd_getmdpubscreenname *rd = *rxd;
  462.  
  463.     switch( action )
  464.     {
  465.         case RXIF_INIT:
  466.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  467.             break;
  468.             
  469.         case RXIF_ACTION:
  470.             /* Insert your CODE here */
  471.             rd->rc = 0;
  472.             rd->rc2 = !wbwindow;
  473.             rd->res.pubscreenname = ( pubscreenname ) ? pubscreenname : "Workbench";
  474.             break;
  475.         
  476.         case RXIF_FREE:
  477.             /* FREE your local data here */
  478.             FreeVec( rd );
  479.             break;
  480.     }
  481.     return;
  482. }
  483. /* $ARB: E 12 GETMDPUBSCREENNAME */
  484.  
  485. /* $ARB: B 13 SENDSHORTMAIL */
  486. void rx_sendshortmail( struct RexxHost *host, struct rxd_sendshortmail **rxd, long action, struct RexxMsg *rexxmsg )
  487. {
  488.     struct rxd_sendshortmail *rd = *rxd;
  489.  
  490.     switch( action )
  491.     {
  492.         case RXIF_INIT:
  493.             *rxd = ARBAlloc( host, sizeof *rd );
  494.             if( rd = *rxd )
  495.             {
  496.                 rd->arg.subject = "";
  497.                 /* set your DEFAULTS here */
  498.             }
  499.             break;
  500.             
  501.         case RXIF_ACTION:
  502.             /* Insert your CODE here */
  503.             sendshortmail( rd->arg.to, rd->arg.subject, rd->arg.text, ( rd->arg.referenceid ) ? rd->arg.referenceid : NULL, NULL, NULL, 1 );
  504.             rd->rc = 0;
  505.             break;
  506.         
  507.         case RXIF_FREE:
  508.             /* FREE your local data here */
  509.             ARBFree( host, rd );
  510.             break;
  511.     }
  512.     return;
  513. }
  514. /* $ARB: E 13 SENDSHORTMAIL */
  515.  
  516. /* $ARB: B 14 SENDMAIL */
  517. extern int sendwinauto;
  518. void rx_sendmail( struct RexxHost *host, struct rxd_sendmail **rxd, long action, struct RexxMsg *rexxmsg )
  519. {
  520.     struct rxd_sendmail *rd = *rxd;
  521.     static ULONG rc;
  522.  
  523.     switch( action )
  524.     {
  525.         case RXIF_INIT:
  526.             *rxd = ARBAlloc( host, sizeof *rd );
  527.             if( rd = *rxd )
  528.             {
  529.                 /* set your DEFAULTS here */
  530.             }
  531.             break;
  532.             
  533.         case RXIF_ACTION:
  534.             sendwinauto = !rd->arg.wait;
  535.             if( !rd->arg.bin )
  536.                 copyfile( rd->arg.bodyfile, TMPMSGNAME );
  537.             if( rd->arg.commentfile )
  538.                 copyfile( rd->arg.commentfile, TMPCOMMENTNAME );
  539.  
  540.             rc = dosendwin( "Per ARexx verschickte Nachricht",
  541.                 rd->arg.subject,
  542.                 rd->arg.shortcomment,
  543.                 rd->arg.referenceid,
  544.                 rd->arg.to,
  545.                 rd->arg.bin ? 1 : 0,
  546.                 NULL, NULL,
  547.                 rd->arg.followup_to,
  548.                 NULL,
  549.                 NULL,
  550.                 ( rd->arg.bin ) ? rd->arg.bodyfile : NULL,
  551.                 ( rd->arg.bin ) ? FilePart( rd->arg.bodyfile ): NULL,
  552.                 NULL
  553.             );
  554.  
  555.             rd->res.rc = &rc;
  556.  
  557.             /* Insert your CODE here */
  558.             rd->rc = 0;
  559.  
  560.             displayscroller();
  561.             break;
  562.         
  563.         case RXIF_FREE:
  564.             /* FREE your local data here */
  565.             ARBFree( host, rd );
  566.             break;
  567.     }
  568.     return;
  569. }
  570. /* $ARB: E 14 SENDMAIL */
  571.  
  572. /* $ARB: B 15 GETCURRENTBOARD */
  573. /* ATT: Interface changed! Check arg/res/name consistency! */
  574. extern struct mbrett *cmb;
  575. void rx_getcurrentboard( struct RexxHost *host, struct rxd_getcurrentboard **rxd, long action, struct RexxMsg *rexxmsg )
  576. {
  577.     struct rxd_getcurrentboard *rd = *rxd;
  578.     struct mbrett *brett=(struct mbrett*)GetEntry( &brettlist, getscrollercurrent() );
  579.     static ULONG holddays, nocrunch, subpm, select;
  580.  
  581.     if( rexxmode )
  582.         brett = cmb;
  583.  
  584.     switch( action )
  585.     {
  586.         case RXIF_INIT:
  587.             *rxd = ARBAlloc( host, sizeof *rd );
  588.             break;
  589.             
  590.         case RXIF_ACTION:
  591.             select = brett->n.ln_Type ? 1 : 0;
  592.             nocrunch = ( brett->b.flags & BFLAG_NOCRUNCH ) ? 1 : 0;
  593.             subpm = ( brett->b.flags & BFLAG_EXTEND_PM ) ? 1 : 0;
  594.  
  595.             /* Insert your CODE here */
  596.             holddays = brett->b.days;
  597.             rd->res.name = StrDup( host, brett->b.name );
  598.             rd->res.mails = &brett->b.mails;
  599.             rd->res.newmails = &brett->b.newmails;
  600.             rd->res.unreadmails = &brett->b.unreadmails;
  601.             rd->res.holddays = &holddays;
  602.             rd->res.nodelete = &nocrunch;
  603.             rd->res.subpm = &subpm;
  604.             rd->res.selected = &select;
  605.             rd->res.updatetime = &brett->b.lastwrite;
  606.             rd->rc = 0;
  607.             break;
  608.         
  609.         case RXIF_FREE:
  610.             /* FREE your local data here */
  611.             ARBFree( host, rd );
  612.             break;
  613.     }
  614.     return;
  615. }
  616. /* $ARB: E 15 GETCURRENTBOARD */
  617.  
  618. /* $ARB: B 16 GETPREFS */
  619. void rx_getprefs( struct RexxHost *host, struct rxd_getprefs **rxd, long action, struct RexxMsg *rexxmsg )
  620. {
  621.     struct rxd_getprefs *rd = *rxd;
  622.  
  623.     switch( action )
  624.     {
  625.         case RXIF_INIT:
  626.             *rxd = ARBAlloc( host, sizeof *rd );
  627.             break;
  628.             
  629.         case RXIF_ACTION:
  630.             /* Insert your CODE here */
  631.             rd->res.username = StrDup( host, prefs.username );
  632.             rd->res.userrealname = StrDup( host, prefs.userrealname );
  633.             rd->res.pointname = StrDup( host, prefs.pointname );
  634.             rd->res.servername = StrDup( host, prefs.boxname );
  635.             rd->res.serverdomain = StrDup( host, prefs.boxdomain );
  636.             rd->rc = 0;
  637.             break;
  638.         
  639.         case RXIF_FREE:
  640.             /* FREE your local data here */
  641.             ARBFree( host, rd );
  642.             break;
  643.     }
  644.     return;
  645. }
  646. /* $ARB: E 16 GETPREFS */
  647.  
  648. /* $ARB: B 17 GETCURRENTMAIL */
  649. /* ATT: Interface changed! Check arg/res/name consistency! */
  650. /* ATT: Interface changed! Check arg/res/name consistency! */
  651. void rx_getcurrentmail( struct RexxHost *host, struct rxd_getcurrentmail **rxd, long action, struct RexxMsg *rexxmsg )
  652. {
  653.     struct rxd_getcurrentmail *rd = *rxd;
  654.  
  655.     switch( action )
  656.     {
  657.         case RXIF_INIT:
  658.             *rxd = ARBAlloc( host, sizeof *rd );
  659.             break;
  660.             
  661.         case RXIF_ACTION:
  662.             /* Insert your CODE here */
  663.             if( ( rexxmode != 1 ) && ( rexxmode != 2 ) )
  664.             {
  665.                 rd->rc = -10;
  666.                 rd->rc2 = (ULONG) "Illegal mode";
  667.                 break;
  668.             }
  669.             else
  670.             {
  671.                 struct vmail *v = getcurrentmail();
  672.  
  673.                 if( v )
  674.                 {
  675.                     static ULONG readf, newf, holdf, delf, binf, showf, rx1f, rx2f, self;
  676.  
  677.                     readf = ( v->m->m.flags & MMF_READ ) ? 1 : 0;
  678.                     newf = ( v->m->m.flags & MMF_UNSEEN ) ? 1 : 0;
  679.                     holdf = ( v->m->m.flags & MMF_ARCHIVE ) ? 1 : 0;
  680.                     delf  = ( v->m->m.flags & MMF_DEL ) ? 1 : 0;
  681.                     binf  = ( v->m->m.flags & MMF_BIN ) ? 1 : 0;
  682.                     showf = ( v->m->m.flags & MMF_SHOW ) ? 1 : 0;
  683.                     rx1f = ( v->m->m.flags & MMF_RX1 ) ? 1 : 0;
  684.                     rx2f = ( v->m->m.flags & MMF_RX2 ) ? 1 : 0;
  685.                     self  = ( v->sel ) ? 1 : 0;
  686.  
  687.                     rd->res.from = StrDup( host, v->m->m.absender );
  688.                     rd->res.fromreal = StrDup( host, v->m->m.absenderreal );
  689.                     rd->res.subject = StrDup( host, v->m->m.betreff );
  690.                     rd->res.midhash = &v->m->m.midcrc;
  691.                     rd->res.refhash = &v->m->m.bezcrc;
  692.                     rd->res.length = &v->m->m.maillen;
  693.                     rd->res.new = &newf;
  694.                     rd->res.read = &readf;
  695.                     rd->res.hold = &holdf;
  696.                     rd->res.del = &delf;
  697.                     rd->res.bin = &binf;
  698.                     rd->res.show = &showf;
  699.                     rd->res.selected = &self;
  700.                     rd->res.rx1 = &rx1f;
  701.                     rd->res.rx2 = &rx2f;
  702.                     rd->res.sendtime = &v->m->m.time;
  703.                     rd->res.incometime = &v->m->m.incomtime;
  704.  
  705.                     rd->rc = 0;
  706.                     break;
  707.                 }
  708.             }
  709.             rd->rc = -10;
  710.             rd->rc = (ULONG) "no current mail";
  711.             break;
  712.         
  713.         case RXIF_FREE:
  714.             /* FREE your local data here */
  715.             ARBFree( host, rd );
  716.             break;
  717.     }
  718.     return;
  719. }
  720. /* $ARB: E 17 GETCURRENTMAIL */
  721.  
  722. /* $ARB: B 18 EDITOR */
  723. void rx_editor( struct RexxHost *host, struct rxd_editor **rxd, long action, struct RexxMsg *rexxmsg )
  724. {
  725.     struct rxd_editor *rd = *rxd;
  726.  
  727.     switch( action )
  728.     {
  729.         case RXIF_INIT:
  730.             *rxd = ARBAlloc( host, sizeof *rd );
  731.             if( rd = *rxd )
  732.             {
  733.                 /* set your DEFAULTS here */
  734.             }
  735.             break;
  736.             
  737.         case RXIF_ACTION:
  738.             /* Insert your CODE here */
  739.             rd->res.rc = 0;
  740.             calleditor( rd->arg.file );
  741.             rd->rc = 0;
  742.             break;
  743.         
  744.         case RXIF_FREE:
  745.             /* FREE your local data here */
  746.             ARBFree( host, rd );
  747.             break;
  748.     }
  749.     return;
  750. }
  751. /* $ARB: E 18 EDITOR */
  752.  
  753. /* $ARB: B 19 GETPOS */
  754. void rx_getpos( struct RexxHost *host, struct rxd_getpos **rxd, long action, struct RexxMsg *rexxmsg )
  755. {
  756.     struct rxd_getpos *rd = *rxd;
  757.     static ULONG pos;
  758.  
  759.     switch( action )
  760.     {
  761.         case RXIF_INIT:
  762.             *rxd = ARBAlloc( host, sizeof *rd );
  763.             break;
  764.             
  765.         case RXIF_ACTION:
  766.             pos = getscrollercurrent();
  767.             rd->res.rc = &pos;
  768.             /* Insert your CODE here */
  769.             rd->rc = 0;
  770.             break;
  771.         
  772.         case RXIF_FREE:
  773.             /* FREE your local data here */
  774.             ARBFree( host, rd );
  775.             break;
  776.     }
  777.     return;
  778. }
  779. /* $ARB: E 19 GETPOS */
  780.  
  781. /* $ARB: B 20 SETPOS */
  782. /* ATT: Interface changed! Check arg/res/name consistency! */
  783. void rx_setpos( struct RexxHost *host, struct rxd_setpos **rxd, long action, struct RexxMsg *rexxmsg )
  784. {
  785.     struct rxd_setpos *rd = *rxd;
  786.  
  787.     switch( action )
  788.     {
  789.         case RXIF_INIT:
  790.             *rxd = ARBAlloc( host, sizeof *rd );
  791.             if( rd = *rxd )
  792.             {
  793.                 /* set your DEFAULTS here */
  794.             }
  795.             break;
  796.             
  797.         case RXIF_ACTION:
  798.             rd->rc = 0;
  799.             if( rd->arg.up )
  800.                 setscrollercurrent( getscrollercurrent() - 1 );
  801.             else if( rd->arg.down )
  802.                 setscrollercurrent( getscrollercurrent() + 1 );
  803.             else if( rd->arg.gotopos )    
  804.                 setscrollercurrent( *rd->arg.gotopos );
  805.             else
  806.                 rd->rc = 1;
  807.  
  808.             showcurrentitem();
  809.  
  810.             /* Insert your CODE here */
  811.             rd->rc = 0;
  812.             break;
  813.         
  814.         case RXIF_FREE:
  815.             /* FREE your local data here */
  816.             ARBFree( host, rd );
  817.             break;
  818.     }
  819.     return;
  820. }
  821. /* $ARB: E 20 SETPOS */
  822.  
  823. /* $ARB: B 21 CHOOSE */
  824. /* ATT: Interface changed! Check arg/res/name consistency! */
  825. /* ATT: Interface changed! Check arg/res/name consistency! */
  826. int scrollerenter;
  827. void rx_choose( struct RexxHost *host, struct rxd_choose **rxd, long action, struct RexxMsg *rexxmsg )
  828. {
  829.     struct rxd_choose *rd = *rxd;
  830.  
  831.     switch( action )
  832.     {
  833.         case RXIF_INIT:
  834.             *rxd = ARBAlloc( host, sizeof *rd );
  835.             if( rd = *rxd )
  836.             {
  837.                 /* set your DEFAULTS here */
  838.             }
  839.             break;
  840.             
  841.         case RXIF_ACTION:
  842.             if( rexxmode == 2 )
  843.             {
  844.                 rd->rc = -10;
  845.                 rd->rc2 = (ULONG) "Illegal mode";
  846.                 break;
  847.             }
  848.             else
  849.             {
  850.                 static int isselected;
  851.  
  852.                 isselected = ( getscrollerselect() ) ? TRUE : FALSE;
  853.  
  854.                 if( rd->arg.off )
  855.                     scrollerselect( 0, 0 );
  856.                 else if( rd->arg.toggle )
  857.                     scrollerselect( 0, !isselected );
  858.                 else if( rd->arg.allon )
  859.                     scrollerselect( TRUE, TRUE );
  860.                 else if( rd->arg.alloff )
  861.                     scrollerselect( TRUE, FALSE );
  862.                 else if( rd->arg.enter )
  863.                     scrollerenter = TRUE;
  864.                 else if( !rd->arg.test )
  865.                     scrollerselect( 0, TRUE );
  866.  
  867.                 if( !rexxmode )
  868.                     calcbcount();
  869.                 else
  870.                     calcmcount();
  871.  
  872.                 rd->res.rc = &isselected;
  873.                 /* Insert your CODE here */
  874.                 rd->rc = 0;
  875.             }
  876.             break;
  877.         
  878.         case RXIF_FREE:
  879.             /* FREE your local data here */
  880.             ARBFree( host, rd );
  881.             break;
  882.     }
  883.     return;
  884. }
  885. /* $ARB: E 21 CHOOSE */
  886.  
  887. /* $ARB: B 22 CRUNCH */
  888. void rx_crunch( struct RexxHost *host, struct rxd_crunch **rxd, long action, struct RexxMsg *rexxmsg )
  889. {
  890.     struct rxd_crunch *rd = *rxd;
  891.  
  892.     switch( action )
  893.     {
  894.         case RXIF_INIT:
  895.             *rxd = ARBAlloc( host, sizeof *rd );
  896.             break;
  897.             
  898.         case RXIF_ACTION:
  899.             if( rexxmode )
  900.             {
  901.                 rd->rc = -10;
  902.                 rd->rc2 = (ULONG) "Illegal mode";
  903.                 break;
  904.             }
  905.             /* Insert your CODE here */
  906.             docrunch( ( struct mbrett*)-1 );
  907.             rd->rc = 0;
  908.             break;
  909.         
  910.         case RXIF_FREE:
  911.             /* FREE your local data here */
  912.             ARBFree( host, rd );
  913.             break;
  914.     }
  915.     return;
  916. }
  917. /* $ARB: E 22 CRUNCH */
  918.  
  919. /* $ARB: B 23 REORG */
  920. void rx_reorg( struct RexxHost *host, struct rxd_reorg **rxd, long action, struct RexxMsg *rexxmsg )
  921. {
  922.     struct rxd_reorg *rd = *rxd;
  923.  
  924.     switch( action )
  925.     {
  926.         case RXIF_INIT:
  927.             *rxd = ARBAlloc( host, sizeof *rd );
  928.             if( rd = *rxd )
  929.             {
  930.                 /* set your DEFAULTS here */
  931.             }
  932.             break;
  933.             
  934.         case RXIF_ACTION:
  935.             if( rexxmode )
  936.             {
  937.                 rd->rc = -10;
  938.                 rd->rc2 = (ULONG) "Illegal mode";
  939.                 break;
  940.             }
  941.             /* Insert your CODE here */
  942.             doreorg2( rd->arg.merge );
  943.             rd->rc = 0;
  944.             break;
  945.         
  946.         case RXIF_FREE:
  947.             /* FREE your local data here */
  948.             ARBFree( host, rd );
  949.             break;
  950.     }
  951.     return;
  952. }
  953. /* $ARB: E 23 REORG */
  954.  
  955. /* $ARB: B 24 NETCALL */
  956. void rx_netcall( struct RexxHost *host, struct rxd_netcall **rxd, long action, struct RexxMsg *rexxmsg )
  957. {
  958.     struct rxd_netcall *rd = *rxd;
  959.  
  960.     switch( action )
  961.     {
  962.         case RXIF_INIT:
  963.             *rxd = ARBAlloc( host, sizeof *rd );
  964.             break;
  965.             
  966.         case RXIF_ACTION:
  967.             if( rexxmode )
  968.             {
  969.                 rd->rc = -10;
  970.                 rd->rc2 = (ULONG) "Illegal mode";
  971.                 break;
  972.             }
  973.             /* Insert your CODE here */
  974.             if( !dospool() )
  975.             {
  976.                 if( !donetcall( 0 ) )
  977.                 {
  978.                     delspool();
  979.                     dosortin();
  980.                     sortbrettlist();
  981.                     calcbcount();
  982.                     displayscroller();
  983.                     rd->res.rc = 0;
  984.                     break;
  985.                 }
  986.             }
  987.             rd->rc = 0;
  988.             break;
  989.         
  990.         case RXIF_FREE:
  991.             /* FREE your local data here */
  992.             ARBFree( host, rd );
  993.             break;
  994.     }
  995.     return;
  996. }
  997. /* $ARB: E 24 NETCALL */
  998.  
  999. /* $ARB: B 25 GOTOBOARD */
  1000. /* ATT: Interface changed! Check arg/res/name consistency! */
  1001. /* ATT: Interface changed! Check arg/res/name consistency! */
  1002. void rx_gotoboard( struct RexxHost *host, struct rxd_gotoboard **rxd, long action, struct RexxMsg *rexxmsg )
  1003. {
  1004.     struct rxd_gotoboard *rd = *rxd;
  1005.     struct mbrett *mb;
  1006.  
  1007.     switch( action )
  1008.     {
  1009.         case RXIF_INIT:
  1010.             *rxd = ARBAlloc( host, sizeof *rd );
  1011.             if( rd = *rxd )
  1012.             {
  1013.                 /* set your DEFAULTS here */
  1014.             }
  1015.             break;
  1016.             
  1017.         case RXIF_ACTION:
  1018.             if( rexxmode )
  1019.             {
  1020.                 rd->rc = -10;
  1021.                 rd->rc2 = (ULONG) "Illegal mode";
  1022.                 break;
  1023.             }
  1024.  
  1025.             mb = findbrett( rd->arg.name, 0 );
  1026.             if( mb )
  1027.             {
  1028.                 setscrollercurrent( GetEntryNum( &brettlist, mb ) );
  1029.                 showcurrentitem();
  1030.                 rd->rc = 0;
  1031.             }
  1032.             else
  1033.                 rd->rc = 5;
  1034.  
  1035.             break;
  1036.         
  1037.         case RXIF_FREE:
  1038.             /* FREE your local data here */
  1039.             ARBFree( host, rd );
  1040.             break;
  1041.     }
  1042.     return;
  1043. }
  1044. /* $ARB: E 25 GOTOBOARD */
  1045.  
  1046. /* $ARB: B 26 SETCURRENTMAILFLAGS */
  1047. extern struct mindex *mix;
  1048. static void setmailflag( long *state, ULONG flag, struct vmail *v )
  1049. {
  1050.     if( state )
  1051.     {
  1052.         if( *state )
  1053.             v->m->m.flags |= flag;
  1054.         else
  1055.             v->m->m.flags &= ~flag;
  1056.         mix->changed = 1;
  1057.     }
  1058. }
  1059.  
  1060. void rx_setcurrentmailflags( struct RexxHost *host, struct rxd_setcurrentmailflags **rxd, long action, struct RexxMsg *rexxmsg )
  1061. {
  1062.     struct rxd_setcurrentmailflags *rd = *rxd;
  1063.     struct vmail *v;
  1064.  
  1065.     switch( action )
  1066.     {
  1067.         case RXIF_INIT:
  1068.             *rxd = ARBAlloc( host, sizeof *rd );
  1069.             if( rd = *rxd )
  1070.             {
  1071.                 /* set your DEFAULTS here */
  1072.             }
  1073.             break;
  1074.             
  1075.         case RXIF_ACTION:
  1076.             if( ( rexxmode != 1 ) && ( rexxmode != 2 ) )
  1077.             {
  1078.                 rd->rc = -10;
  1079.                 rd->rc2 = (ULONG) "Illegal mode";
  1080.                 break;
  1081.             }
  1082.  
  1083.             v = getcurrentmail();
  1084.             if( v )
  1085.             {
  1086.                 setmailflag( rd->arg.new, MMF_UNSEEN, v );
  1087.                 setmailflag( rd->arg.read, MMF_READ, v );
  1088.                 setmailflag( rd->arg.hold, MMF_ARCHIVE, v );
  1089.                 setmailflag( rd->arg.del, MMF_DEL, v );
  1090.                 setmailflag( rd->arg.show, MMF_SHOW, v );
  1091.                 setmailflag( rd->arg.rx1, MMF_RX1, v );
  1092.                 setmailflag( rd->arg.rx2, MMF_RX2, v );
  1093.                 if( rd->arg.selected )
  1094.                 {
  1095.                     if( *rd->arg.selected )
  1096.                         v->sel = 0xff;
  1097.                     else
  1098.                         v->sel = 0;
  1099.                 }
  1100.                 displaycurrentline();
  1101.                 calcmcount();
  1102.             }
  1103.             /* Insert your CODE here */
  1104.             rd->rc = 0;
  1105.             break;
  1106.         
  1107.         case RXIF_FREE:
  1108.             /* FREE your local data here */
  1109.             ARBFree( host, rd );
  1110.             break;
  1111.     }
  1112.     return;
  1113. }
  1114. /* $ARB: E 26 SETCURRENTMAILFLAGS */
  1115.  
  1116. /* $ARB: B 28 REQUEST */
  1117. void rx_request( struct RexxHost *host, struct rxd_request **rxd, long action, struct RexxMsg *rexxmsg )
  1118. {
  1119.     struct rxd_request *rd = *rxd;
  1120.     static ULONG rc;
  1121.  
  1122.     switch( action )
  1123.     {
  1124.         case RXIF_INIT:
  1125.             *rxd = ARBAlloc( host, sizeof *rd );
  1126.             if( rd = *rxd )
  1127.             {
  1128.                 /* set your DEFAULTS here */
  1129.             }
  1130.             break;
  1131.             
  1132.         case RXIF_ACTION:
  1133.             rc = askreq( rd->arg.text, rd->arg.gadgets );
  1134.             rd->res.rc = &rc;
  1135.             /* Insert your CODE here */
  1136.             rd->rc = 0;
  1137.             break;
  1138.         
  1139.         case RXIF_FREE:
  1140.             /* FREE your local data here */
  1141.             ARBFree( host, rd );
  1142.             break;
  1143.     }
  1144.     return;
  1145. }
  1146. /* $ARB: E 28 REQUEST */
  1147.  
  1148. /* $ARB: B 30 QUIT */
  1149. extern int rexxquitflag;
  1150. void rx_quit( struct RexxHost *host, struct rxd_quit **rxd, long action, struct RexxMsg *rexxmsg )
  1151. {
  1152.     struct rxd_quit *rd = *rxd;
  1153.  
  1154.     switch( action )
  1155.     {
  1156.         case RXIF_INIT:
  1157.             *rxd = ARBAlloc( host, sizeof *rd );
  1158.             break;
  1159.             
  1160.         case RXIF_ACTION:
  1161.             rexxquitflag = TRUE;
  1162.             /* Insert your CODE here */
  1163.             rd->rc = 0;
  1164.             break;
  1165.         
  1166.         case RXIF_FREE:
  1167.             /* FREE your local data here */
  1168.             ARBFree( host, rd );
  1169.             break;
  1170.     }
  1171.     return;
  1172. }
  1173. /* $ARB: E 30 QUIT */
  1174.  
  1175. /* $ARB: B 31 NOREQUEST */
  1176. extern int noreq;
  1177. void rx_norequest( struct RexxHost *host, struct rxd_norequest **rxd, long action, struct RexxMsg *rexxmsg )
  1178. {
  1179.     struct rxd_norequest *rd = *rxd;
  1180.  
  1181.     switch( action )
  1182.     {
  1183.         case RXIF_INIT:
  1184.             *rxd = ARBAlloc( host, sizeof *rd );
  1185.             if( rd = *rxd )
  1186.             {
  1187.                 /* set your DEFAULTS here */
  1188.             }
  1189.             break;
  1190.             
  1191.         case RXIF_ACTION:
  1192.             /* Insert your CODE here */
  1193.             if( rd->arg.off )
  1194.                 noreq = FALSE;
  1195.             else
  1196.                 noreq = TRUE;
  1197.             rd->rc = 0;
  1198.             break;
  1199.         
  1200.         case RXIF_FREE:
  1201.             /* FREE your local data here */
  1202.             ARBFree( host, rd );
  1203.             break;
  1204.     }
  1205.     return;
  1206. }
  1207. /* $ARB: E 31 NOREQUEST */
  1208.  
  1209.  
  1210. #ifndef RX_ALIAS_C
  1211. char *ExpandRXCommand( struct RexxHost *host, char *command )
  1212. {
  1213.     /* Insert your ALIAS-HANDLER here */
  1214.     return( NULL );
  1215. }
  1216. #endif
  1217.  
  1218.