home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / old / ckermit4e / ckmutl.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  30KB  |  1,045 lines
  1. /* Version 0.8(35) - Jim Noble at Planning Research Corporation, June 1987. */
  2. /* Ported to Megamax native Macintosh C compiler. */
  3. /* Edit by Frank on 20 Jun 5:25pm */
  4. /* In commdialog(), don't set parity on sio chip. */
  5. /* Edit by Bill on Apr 30 00:11 */
  6. /* use mygetitem instead of getitem, it doesn't convert from pascal to c */
  7. /* Redo handapple */
  8. /* Edit by Bill on Apr 21 17:27 */
  9. /* Try to fix meaning of TURN and TURNCH in dialog box */
  10. /* Remove version from dofiledialog dialog box */
  11.  
  12. /*
  13.  * file ckmutl.c
  14.  *
  15.  * Module of mackermit containing code for the menus and other MacIntosh
  16.  * things.
  17.  *
  18.  */
  19.  
  20. /*
  21.  Copyright (C) 1985, Trustees of Columbia University in the City of New York.
  22.  Permission is granted to any individual or institution to use, copy, or
  23.  redistribute this software so long as it is not sold for profit, provided this
  24.  copyright notice is retained.
  25. */
  26.  
  27. #include <ctype.h>        /* For isdigit */
  28. #include "ckcdeb.h"
  29. #include "ckcker.h"
  30.  
  31. #define    __SEG__ KStuff
  32. #include <controls.h>
  33. #include <dialogs.h>
  34. #include <packages.h>
  35. #include <serial.h>
  36. #include <menus.h>
  37. #include <resources.h>
  38. #include <events.h>
  39. #include <toolutils.h>
  40. #include <segload.h>
  41.     /* for ExitToShell (I don't know why it's in here...) */
  42.  
  43. #include "ckmdef.h"        /* General Mac defs */
  44. #include "ckmres.h"        /* Resource file defs */
  45. #include "ckmasm.h"        /* Assembler code */
  46.  
  47. extern MenuHandle menus[];
  48.  
  49.  
  50.  
  51. /****************************************************************************/
  52. /*  B L D L E N  --  Make length-encoded copy of string  */
  53. /****************************************************************************/
  54. char *
  55. bldlen (str, dest)
  56. char *str;
  57. char *dest;
  58. {
  59.     int len;
  60.  
  61.     len = strlen (str);
  62.     *dest = tochar (len);
  63.     strcpy (dest + 1, str);
  64.     return (dest + len + 1);
  65. }                /* bldlen */
  66.  
  67.  
  68.  
  69. /****************************************************************************/
  70. /*  S E T G E N  --  Construct a generic command  */
  71. /****************************************************************************/
  72. setgen (stor, type, arg1, arg2, arg3)
  73. char *stor;
  74. char type;
  75. char *arg1;
  76. char *arg2;
  77. char *arg3;
  78. {
  79.     char *upstr, *cp;
  80.  
  81.     cp = stor;
  82.     *cp++ = type;
  83.     *cp = '\0';
  84.     if (*arg1 != '\0') {
  85.     upstr = bldlen (arg1, cp);
  86.     if (*arg2 != '\0') {
  87.         upstr = bldlen (arg2, upstr);
  88.         if (*arg3 != '\0')
  89.         bldlen (arg3, upstr);
  90.     }
  91.     }
  92.     debug (F110, "setgen", stor, 0);
  93. }                /* setgen */
  94.  
  95.  
  96.  
  97. /****************************************************************************/
  98. /* printerr - display error message and number in standard error box. */
  99. /****************************************************************************/
  100. printerr (str, err)
  101. char *str;
  102. int err;
  103. {
  104.     int i;
  105.     char error[10];
  106.  
  107.     if (str == NULL || str[0] == 0)
  108.     str = "OOPS: printerr called with an empty string";
  109.  
  110.     if (err) {            /* Err=0 signals message only */
  111.     for (i = 0; i < 10; error[i++] = '\0');    /* Make string null
  112.                          * terminated */
  113.     NumToString ((long) err, error);    /* Convert err number */
  114.     ParamText (str, error, "", "");    /* Insert strings into error box */
  115.     } else
  116.     ParamText (str, "", "", "");
  117.  
  118.     if (!server)        /* Display alert only if not server mode */
  119.     NoteAlert (ALERT_ERROR, NILPROC);
  120. }                /* printerr */
  121.  
  122.  
  123.  
  124. /****************************************************************************/
  125. /* fatal - close file, and exit to shell.    */
  126. /****************************************************************************/
  127. fatal (str, err)
  128. char *str;
  129. int err;
  130. {
  131.     int i;
  132.     char error[10];
  133.  
  134.     if (err) {            /* Err=0 signals message only */
  135.     for (i = 0; i < 10; error[i++] = '\0');    /* Make string null
  136.                          * terminated */
  137.     NumToString ((long) err, error);    /* Convert err number */
  138.     ParamText ("Fatal error:", str, error, "");    /* Insert strings into
  139.                              * error box */
  140.     } else
  141.     ParamText ("Fatal error:", str, "", "");
  142.  
  143.     if (!server)        /* Display alert only if not server mode */
  144.     StopAlert (ALERT_ERROR, NILPROC);
  145.  
  146.     /*
  147.      * terminate NOW!  The heap might be scrambled, so don't try to clean
  148.      * anything up.
  149.      */
  150.     ExitToShell ();
  151. }                /* fatal */
  152.  
  153.  
  154.  
  155. /****************************************************************************/
  156. /* SetStrText - Set the string value in the dialog's edit or static text
  157.    item.    */
  158. /****************************************************************************/
  159. SetStrText (item, s, dlg)
  160. int item;
  161. char *s;
  162. DialogPtr dlg;
  163. {
  164.     short itemtype;
  165.     Rect itemrect;
  166.     Handle itemhdl;
  167.  
  168.     GetDItem (dlg, item, &itemtype, &itemhdl, &itemrect);
  169.     if ((itemtype & editText) || (itemtype & statText))
  170.     SetIText (itemhdl, s);
  171.     else
  172.     printerr ("Bad item in SetStrText: ", item);
  173. }                /* SetStrText */
  174.  
  175.  
  176.  
  177. /****************************************************************************/
  178. /* SetNumText - Set the numeric value in the dialog's edit or static text
  179.    item.    */
  180. /****************************************************************************/
  181. SetNumText (item, val, dlg)
  182. int item;
  183. int val;
  184. DialogPtr dlg;
  185. {
  186.     char itembuf[10];
  187.  
  188.     NumToString ((long) val, itembuf);
  189.     SetStrText (item, itembuf, dlg);
  190. }                /* SetNumText */
  191.  
  192. /*PWP************************************************************************/
  193. /* circleOK - Circle the default button for a dialog (since the dialog manager
  194.  * doesn't do this for us. */
  195. /****************************************************************************/
  196. circleOK(dlg)
  197. DialogPtr dlg;
  198. {
  199.     short itemtype;
  200.     Rect itemrect;
  201.     Handle itemhdl;
  202.     GrafPtr oldport;
  203.  
  204.     GetDItem (dlg, 1, &itemtype, &itemhdl, &itemrect);
  205.     if (itemtype != (ctrlItem | btnCtrl))
  206.     return;        /* it wasn't a button */
  207.  
  208.     GetPort(&oldport);
  209.     SetPort(dlg);
  210.     /* PWP: might have to do a local-->global on the rect here */
  211.     PenSize(3,3);    /* see IM 1, page 407 (dialog manager) */
  212.     InsetRect(&itemrect,-4,-4);
  213.     FrameRoundRect(&itemrect,16,16);
  214.     SetPort(oldport);
  215. }                /* SetStrText */
  216.  
  217.  
  218. extern char *protv;
  219. extern int tsecs;        /* Seconds for transaction */
  220. extern long filcnt,        /* Number of files in transaction */
  221.     flci,            /* Characters from line, current file */
  222.     flco,            /* Chars to line, current file  */
  223.     tlci,            /* Chars from line in transaction */
  224.     tlco,            /* Chars to line in transaction */
  225.     ffc,            /* Chars to/from current file */
  226.     tfc;            /* Chars to/from files in transaction */
  227.  
  228. /****************************************************************************/
  229. /* aboutKermit - Display the about kermit dialog box, and some transaction */
  230. /*                    statistics */
  231. /****************************************************************************/
  232. aboutKermit ()
  233. {
  234.     Handle kversion;
  235.     short itemhit;
  236.     DialogPtr aboutDlg;
  237.  
  238.     aboutDlg = GetNewDialog (ABOUTID, NILPTR, (WindowPtr) - 1);
  239.     circleOK(aboutDlg);
  240.     
  241.     kversion = GetResource (ApplCreator, 0);    /* get version information */
  242.     HLock (kversion);        /* prevent movement */
  243.     p2cstr (*kversion);        /* convert to C string */
  244.  
  245.     SetStrText (AB_VERS, *kversion, aboutDlg);
  246.     SetStrText (AB_PROV, protv, aboutDlg);
  247.     SetNumText (AB_TSEC, tsecs, aboutDlg);
  248.     SetNumText (AB_TLCI, tlci, aboutDlg);
  249.     SetNumText (AB_TLCO, tlco, aboutDlg);
  250.     SetNumText (AB_TFC, tfc, aboutDlg);
  251.     if (tsecs > 0)
  252.     SetNumText (AB_EBAUD, ((tfc*10)/tsecs), aboutDlg);
  253.     else
  254.     SetStrText (AB_EBAUD, "n/a", aboutDlg);
  255.  
  256.     ModalDialog (NILPROC, &itemhit);
  257.     DisposDialog (aboutDlg);
  258.  
  259.     HUnlock (kversion);        /* undo previous HLock */
  260.     ReleaseResource (kversion);    /* no longer needed */
  261. }                /* aboutKermit */
  262.  
  263.  
  264.  
  265. /****************************************************************************/
  266. /* handapple - Handle the apple menu, either running a desk accessory */
  267. /*               or calling a routine to display information about our */
  268. /*               program.  Use the practice of */
  269. /*               checking for available memory, and saving the GrafPort */
  270. /*               described in the DA Manager's Guide. */
  271. /****************************************************************************/
  272. handapple (accitem)
  273. int accitem;
  274. {
  275.     GrafPtr savePort;        /* Where to save current port */
  276.     Handle acchdl;        /* holds ptr to accessory resource */
  277.     char accname[255];        /* string holds accessory name */
  278.     long accsize;        /* holds size of the acc + stack */
  279.  
  280.     if (accitem == 1) {        /* tell about Kermit? */
  281.     aboutKermit ();        /* yes, "about kermit" please */
  282.     return;            /* and return */
  283.     }
  284.     GetItem (menus[APPL_MENU], accitem, accname); /* get the pascal name */
  285.     SetResLoad (FALSE);        /* don't load into memory */
  286.  
  287.     /* figure out acc size + heap */
  288.     accsize = SizeResource (GetNamedResource ((ResType) 'DRVR', accname));
  289.     acchdl = NewHandle (accsize);    /* try for a block this size */
  290.     SetResLoad (TRUE);        /* reset flag for rsrc mgr */
  291.     if (acchdl == NIL) {    /* able to get a chunk? */
  292.     printerr ("Not enough memory for accessory. Requires: ",
  293.           (int) accsize);
  294.     return;            /* failed */
  295.     }
  296.     DisposHandle (acchdl);    /* get rid of this handle */
  297.     GetPort (&savePort);    /* save the current port */
  298.     OpenDeskAcc (accname);    /* run desk accessory */
  299.     SetPort (savePort);        /* and put back our port */
  300. }                /* handapple */
  301.  
  302.  
  303.  
  304. typedef struct {
  305.     unsigned kerval;
  306.     int macval;
  307. }   KMTBL;
  308.  
  309. KMTBL kerbaudtbl[] = {
  310.     {300, baud300},
  311.     {600, baud600},
  312.     {1200, baud1200},
  313.     {1800, baud1800},
  314.     {2400, baud2400},
  315.     {4800, baud4800},
  316.     {7200, baud7200},
  317.     {9600, baud9600},
  318.     {19200, baud19200},
  319.     {57600, baud57600}
  320. };
  321.  
  322. #define kerbaudlen ((sizeof (kerbaudtbl))/(sizeof (KMTBL)))
  323.  
  324. KMTBL kerparitytbl[] = {
  325.     {KPARITY_ODD, MPARITY_ODD},
  326.     {KPARITY_EVEN, MPARITY_EVEN},
  327.     {KPARITY_MARK, MPARITY_MARK},
  328.     {KPARITY_SPACE, MPARITY_SPACE},
  329.     {KPARITY_NONE, MPARITY_NONE}
  330. };
  331.  
  332. #define kerparitylen ((sizeof (kerparitytbl))/(sizeof (KMTBL)))
  333.  
  334. /****************************************************************************/
  335. /* setserial - set the baud and parity for the serial port.    */
  336. /****************************************************************************/
  337. setserial (irefnum, orefnum, b, p)
  338. {
  339.     int err, i, mb, mp = 0;
  340.  
  341.     speed = b;            /* set global kermit value */
  342.  
  343.     for (i = 0; i <= kerbaudlen; i++)
  344.     if (kerbaudtbl[i].kerval == b)
  345.         mb = kerbaudtbl[i].macval;    /* set mac value for baud */
  346.  
  347. /*
  348.  * PWP: if MAC_DOES_PARITY gets defined, then Even parity seems to not work
  349.  * correctly, so we leave it undefined, and have Kermit to parity in
  350.  * software.
  351.  */
  352. #ifdef MAC_DOES_PARITY
  353.     for (i = 0; i <= kerparitylen; i++)
  354.     if (kerparitytbl[i].kerval == p)
  355.         mp = kerparitytbl[i].macval;    /* set mac value for parity */
  356. #else
  357.     mp = MPARITY_NONE;
  358. #endif
  359.  
  360.     err = SerReset (irefnum, mb + mp);    /* reset serial input port */
  361.     if (err != noErr)
  362.     fatal ("setserial couldn't set port (input): ", err);
  363.  
  364.     err = SerReset (orefnum, mb + mp);    /* reset serial output port */
  365.     if (err != noErr)
  366.     fatal ("setserial couldn't set port (output): ", err);
  367. }                /* setserial */
  368.  
  369.  
  370.  
  371. typedef struct {
  372.     int resval;
  373.     unsigned serval;
  374. }   RESSERTBL;
  375.  
  376. RESSERTBL commbaudtbl[] = {
  377.     {CR_BAUD300, 300},
  378.     {CR_BAUD600, 600},
  379.     {CR_BAUD1200, 1200},
  380.     {CR_BAUD1800, 1800},
  381.     {CR_BAUD2400, 2400},
  382.     {CR_BAUD4800, 4800},
  383.     {CR_BAUD7200, 7200},
  384.     {CR_BAUD9600, 9600},
  385.     {CR_BAUD19200, 19200},
  386.     {CR_BAUD57600, 57600},
  387.     {0, 0}
  388. };
  389.  
  390. RESSERTBL commparitytbl[] = {
  391.     {CR_PARODD, KPARITY_ODD},
  392.     {CR_PAREVEN, KPARITY_EVEN},
  393.     {CR_PARMARK, KPARITY_MARK},
  394.     {CR_PARSPACE, KPARITY_SPACE},
  395.     {CR_PARNONE, KPARITY_NONE},
  396.     {0, 0}
  397. };
  398.  
  399. /****************************************************************************/
  400. /* rshilite - hilite the radio control item matching the given */
  401. /*          serial value, and disable all other control items in the */
  402. /*          resource-serial table. */
  403. /****************************************************************************/
  404. rshilite (servalue, rstbl, dlg)
  405. int servalue;
  406. RESSERTBL rstbl[];
  407. DialogPtr dlg;
  408. {
  409.     int i;
  410.     short itemtype;
  411.     Rect itembox;
  412.     Handle itemhdl;
  413.  
  414.     for (i = 0; rstbl[i].resval != 0; i++) {
  415.     GetDItem (dlg, rstbl[i].resval, &itemtype, &itemhdl, &itembox);
  416.  
  417.     if (itemtype != ctrlItem + radCtrl)
  418.         printerr ("rshilite called with non radio control: ",
  419.               rstbl[i].resval);
  420.  
  421.     if (rstbl[i].serval == servalue)
  422.         SetCtlValue ((ControlHandle) itemhdl, btnOn);
  423.     else
  424.         SetCtlValue ((ControlHandle) itemhdl, btnOff);
  425.     }
  426. }                /* rshilite */
  427.  
  428.  
  429.  
  430. /****************************************************************************/
  431. /****************************************************************************/
  432. rsreference (rstbl, value, dlg)
  433. RESSERTBL rstbl[];
  434. DialogPtr dlg;
  435. int value;
  436. {
  437.     int i;
  438.     short itemtype;
  439.     Rect itembox;
  440.     Handle itemhdl;
  441.  
  442.     for (i = 0; rstbl[i].resval != 0; i++) {
  443.     GetDItem (dlg, rstbl[i].resval, &itemtype, &itemhdl, &itembox);
  444.     SetCRefCon ((ControlHandle) itemhdl, (long) value);
  445.     }
  446. }                /* rsreference */
  447.  
  448.  
  449.  
  450. /****************************************************************************/
  451. /* rsserval - given a resource ID for a control and a resource-serial */
  452. /*              table, return the serial value. */
  453. /****************************************************************************/
  454. int
  455. rsserval (resvalue, rstbl)
  456. int resvalue;
  457. RESSERTBL rstbl[];
  458. {
  459.     int i;
  460.  
  461.     for (i = 0; rstbl[i].resval != 0; i++)
  462.     if (rstbl[i].resval == resvalue)
  463.         return (rstbl[i].serval);
  464.  
  465.     fatal ("rsserval didn't find: ", resvalue);
  466.     return (0);            /* never get here */
  467. }                /* rsserval */
  468.  
  469.  
  470.  
  471. #define CREF_BAUD 1
  472. #define CREF_PARITY 2
  473.  
  474. /****************************************************************************/
  475. /* commdialog - enter communications setup dialog. */
  476. /****************************************************************************/
  477. commdialog ()
  478. {
  479.     DialogPtr commdlg;
  480.     long i;
  481.     short itemhit;
  482.     short itemtype;
  483.     int dlgspeed;
  484.     int dlgparity;
  485.  
  486.     Handle itemhdl;
  487.     Rect itembox;
  488.  
  489.     commdlg = GetNewDialog (COMMBOXID, NILPTR, (WindowPtr) - 1);
  490.     circleOK(commdlg);
  491.     
  492.     dlgspeed = speed;        /* initialize to current global */
  493.     dlgparity = parity;        /* values of baud and parity */
  494.  
  495.     rshilite (dlgspeed, commbaudtbl, commdlg);    /* hilite our baud */
  496.     rshilite (dlgparity, commparitytbl, commdlg); /* hilite our parity */
  497.  
  498. /* for all baud and parity controls set the reference value for each
  499.  * control to the resource-serial table address so we can manipulate
  500.  * these controls easily during the dialog processing.
  501.  */
  502.  
  503.     rsreference (commbaudtbl, CREF_BAUD, commdlg); /* setup control ref's */
  504.     rsreference (commparitytbl, CREF_PARITY, commdlg);
  505.  
  506.     for (;;) {
  507.     ModalDialog (NILPROC, &itemhit);
  508.  
  509.     switch (itemhit) {
  510.       case OKBtn:
  511.         parity = dlgparity;
  512.         setserial (innum, outnum, dlgspeed, KPARITY_NONE);
  513.  
  514.       case QuitBtn:
  515.         DisposDialog (commdlg);    /* finished with the dialog */
  516.         return;        /* so return */
  517.  
  518.       default:        /* default is radio button */
  519.         GetDItem (commdlg, itemhit, &itemtype, &itemhdl, &itembox);
  520.         i = GetCRefCon ((ControlHandle) itemhdl);
  521.  
  522.         switch (i) {
  523.           case CREF_BAUD:
  524.         dlgspeed = rsserval (itemhit, commbaudtbl);
  525.         rshilite (dlgspeed, commbaudtbl, commdlg);
  526.         break;
  527.  
  528.           case CREF_PARITY:
  529.         dlgparity = rsserval (itemhit, commparitytbl);
  530.         rshilite (dlgparity, commparitytbl, commdlg);
  531.         break;
  532.  
  533.           default:
  534.         printerr ("Item has no refcon: ", itemhit);
  535.         }
  536.     }
  537.     }
  538. }                /* commdialog */
  539.  
  540.  
  541.  
  542. RESSERTBL protoblktbl[] = {    /* block check:  */
  543.     {PR_BLK1, 1},        /* type 1 */
  544.     {PR_BLK2, 2},        /* type 2 */
  545.     {PR_BLK3, 3},        /* type 3 */
  546.     {0, 0}
  547. };
  548.  
  549. #define KTURN_NONE 0128        /* indicate no handshake */
  550.  
  551. RESSERTBL protohstbl[] = {    /* hand shake: */
  552.     {PR_HSBELL, 7},        /* bell = 7 */
  553.     {PR_HSCR, 15},        /* cr = 15 */
  554.     {PR_HSESC, 33},        /* esc = 33  */
  555.     {PR_HSLF, 12},        /* lf = 12 */
  556.     {PR_HSNONE, KTURN_NONE},    /* none = 128 */
  557.     {PR_HSXON, XON},        /* xon = 21 */
  558.     {PR_HSXOFF, 23},        /* xoff = 23 */
  559.     {0, 0}
  560. };
  561.  
  562. RESSERTBL protointtbl[] = {    /* edit text integer items: */
  563.     {PR_INPADN, 0},        /* inbound pad count edit text */
  564.     {PR_OUTPADN, 1},        /* outbound pad count edit text */
  565.     {PR_INTIMEO, 2},        /* inbound secs timeout edit text */
  566.     {PR_OUTTIMEO, 3},        /* outbound secs timeout edit text */
  567.     {PR_INPKTLEN, 4},        /* inbound packet length edit text */
  568.     {PR_OUTPKTLEN, 5},        /* outbound packet length edit text */
  569.     {0, 0}
  570. };
  571.  
  572. int *protointcells[] = {    /* parallel to above table! */
  573.     &mypadn,            /* inbound pad count */
  574.     &npad,            /* outbound pad count */
  575.     &timint,            /* inbound timeout in secs */
  576.     &rtimo,            /* outbound timeout in secs */
  577.     &urpsiz,            /* user requested inbound pkt length */
  578.     &spsiz            /* inbound pkt length */
  579. };
  580.  
  581. RESSERTBL protochrtbl[] = {    /* edit text character items: */
  582.     {PR_INPADC, 0},        /* inbound pad chr edit text */
  583.     {PR_OUTPADC, 1},        /* outbound pad chr */
  584.     {PR_INEOP, 2},        /* inbound end of packet edit text */
  585.     {PR_OUTEOP, 3},        /* outbound end of packet edit text */
  586.     {PR_INSOP, 4},        /* inbound start of pkt edit text */
  587.     {PR_OUTSOP, 5},        /* outbound start of pkt edit text */
  588.     {0, 0}
  589. };
  590.  
  591. char *protochrcells[] = {    /* parallel to above table! */
  592.     &mypadc,            /* inbound pad char */
  593.     &padch,            /* outbound pad char */
  594.     &eol,            /* inbound end of packet char */
  595.     &seol,            /* outbound end of pkt char */
  596.     &stchr,            /* inbound start of pkt char */
  597.     &mystch            /* outbound start of packet char */
  598. };
  599.  
  600. /****************************************************************************/
  601. /* etgetcc - Set edit text paramter from dialog window to an ASCII */
  602. /*             control character value.  Returns FALSE if value is */
  603. /*             illegal, warning has been displayed. */
  604. /****************************************************************************/
  605. int
  606. etgetcc (item, dlg, chrcell)
  607. DialogPtr dlg;
  608. int item;
  609. char *chrcell;
  610. {
  611.     short itemtype;
  612.     int i;
  613.     long rslt;
  614.     Rect itemrect;
  615.     Handle itemhdl;
  616.     char itembuf[256], c;
  617.  
  618.     GetDItem (dlg, item, &itemtype, &itemhdl, &itemrect);
  619.     if (itemtype != editText) {
  620.     printerr ("etsetcc item not editText: ", item);
  621.     return (FALSE);
  622.     }
  623.     GetIText (itemhdl, itembuf);
  624.     /* p2cstr(itembuf);            /* convert to c string */
  625.     for (i = 0; (c = itembuf[i]) != 0; i++)    /* check for digits */
  626.     if (!isdigit (c)) {
  627.         printerr ("Field contains a non numeric, code ", c);
  628.         return (FALSE);
  629.     }
  630.     StringToNum (itembuf, &rslt);
  631.     if ((rslt > 037) && (rslt != 0177)) {
  632.     printerr ("Not in ASCII control range: ", (int) rslt);
  633.     return (FALSE);
  634.     }
  635.     *chrcell = (char) rslt;
  636.     return (TRUE);
  637. }                /* etgetcc */
  638.  
  639.  
  640.  
  641. /****************************************************************************/
  642. /* etgetnum - Set edit text paramet from dialog to numeric cell. */
  643. /*              Returns FALSE if value is non numeric or not in range */
  644. /*              in which case an error message is printed. */
  645. /****************************************************************************/
  646. int
  647. etgetnum (item, dlg, intcell)
  648. DialogPtr dlg;
  649. int item;
  650. int *intcell;
  651. {
  652.     short itemtype;
  653.     int i;
  654.     long rslt;
  655.     Rect itemrect;
  656.     Handle itemhdl;
  657.     char itembuf[256];
  658.     char c;
  659.  
  660.     GetDItem (dlg, item, &itemtype, &itemhdl, &itemrect);
  661.     if (itemtype != editText) {
  662.     printerr ("etsetnum item not editText: ", item);
  663.     return (FALSE);
  664.     }
  665.     GetIText (itemhdl, itembuf);
  666.  
  667.     for (i = 0; (c = itembuf[i]) != 0; i++)    /* check for digits */
  668.     if (!isdigit (c)) {
  669.         printerr ("Field contains a non numeric, code ", c);
  670.         return (FALSE);
  671.     }
  672.     StringToNum (itembuf, &rslt);
  673.  
  674.     /* check inbound packet length */
  675.     if ((item == PR_INPKTLEN) && (rslt > MAXRP)) {
  676.     printerr ("Sorry, the maximum receive packet length is ", MAXRP);
  677.     return (FALSE);
  678.     }
  679.     /* check outbound packet length */
  680.     if ((item == PR_OUTPKTLEN) && (rslt > MAXSP)) {
  681.     printerr ("Sorry, the maximum send packet length is ", MAXSP);
  682.     return (FALSE);
  683.     }
  684.     *intcell = (int) rslt;
  685.     return (TRUE);
  686. }                /* etgetnum */
  687.  
  688.  
  689.  
  690. #define PREF_BLKCHK 1
  691. #define PREF_HNDSHK 2
  692.  
  693. /****************************************************************************/
  694. /* protodialog - enter protocol setup dialog. */
  695. /****************************************************************************/
  696. protodialog ()
  697. {
  698.     DialogPtr protoDialog;
  699.     long i;
  700.     short itemhit;
  701.     short itemtype;
  702.     int dlgval;
  703.     int dlgint;
  704.     int dlgbctr;
  705.     int dlgturnch;
  706.     Handle itemhdl;
  707.     Rect itembox;
  708.     char dlgchr;
  709.  
  710.     protoDialog = GetNewDialog (PROTOBOXID, NILPTR, (WindowPtr) - 1);
  711.     circleOK(protoDialog);
  712.     
  713.     dlgbctr = bctr;        /* init local block check */
  714.     dlgturnch = turnch;        /* handshake */
  715.     if (!turn)            /* no turn character? */
  716.     dlgturnch = KTURN_NONE;    /* indicate none */
  717.  
  718.     /* for all button controls set the reference value */
  719.     rsreference (protohstbl, PREF_HNDSHK, protoDialog);
  720.     rsreference (protoblktbl, PREF_BLKCHK, protoDialog);
  721.  
  722.     /* for each button controls, hilite the current setting */
  723.     rshilite (dlgturnch, protohstbl, protoDialog); /* hilite our hand shake */
  724.     rshilite (dlgbctr, protoblktbl, protoDialog); /* hilite our block check */
  725.  
  726.     /* for each edit text item, set current value in edit text */
  727.     for (i = 0; protochrtbl[i].resval != 0; i++)
  728.     SetNumText (protochrtbl[i].resval,
  729.             (int) *protochrcells[i], protoDialog);
  730.  
  731.     for (i = 0; protointtbl[i].resval != 0; i++)
  732.     SetNumText (protointtbl[i].resval,
  733.             *protointcells[i], protoDialog);
  734.  
  735.     for (;;) {
  736.     ModalDialog (NILPROC, &itemhit);
  737.  
  738.     switch (itemhit) {
  739.       case OKBtn:        /* finish up */
  740.         turnch = dlgturnch;    /* set global handshake */
  741.         turn = (turnch == KTURN_NONE) ? FALSE : TRUE; /* set turn */
  742.         bctr = dlgbctr;    /* set block type check */
  743.  
  744.         for (i = 0; protochrtbl[i].resval != 0; i++) /* set chr vals */
  745.         if (!etgetcc (protochrtbl[i].resval, protoDialog,
  746.                   protochrcells[i]))
  747.             fatal ("During OKBtn etgetcc failed!", (int) i);
  748.  
  749.         for (i = 0; protointtbl[i].resval != 0; i++) /* set int vals */
  750.         if (!etgetnum (protointtbl[i].resval, protoDialog,
  751.                    protointcells[i]))
  752.             fatal ("During OKBtn etgetnum failed!", (int) i);
  753.  
  754.       case QuitBtn:    /* fall in from above */
  755.         DisposDialog (protoDialog);    /* finished with the dialog */
  756.         return;        /* return */
  757.  
  758.       case PR_INPADC:
  759.       case PR_OUTPADC:
  760.       case PR_INEOP:
  761.       case PR_OUTEOP:
  762.       case PR_INSOP:
  763.       case PR_OUTSOP:
  764.         if (!etgetcc (itemhit, protoDialog, &dlgchr)) {
  765.         /* get back tbl idx */
  766.         dlgval = rsserval (itemhit, protochrtbl);
  767.         dlgval = (int) *protochrcells[dlgval];    /* now cell value */
  768.         SetNumText (itemhit, dlgval, protoDialog); /* and reset it */
  769.         }
  770.         break;
  771.  
  772.       case PR_INPADN:
  773.       case PR_OUTPADN:
  774.       case PR_INTIMEO:
  775.       case PR_OUTTIMEO:
  776.       case PR_INPKTLEN:
  777.       case PR_OUTPKTLEN:
  778.         if (!etgetnum (itemhit, protoDialog, &dlgint)) {
  779.         /* get back tbl idx */
  780.         dlgval = rsserval (itemhit, protointtbl);
  781.         dlgval = *protointcells[dlgval];    /* now cell value */
  782.         SetNumText (itemhit, dlgval, protoDialog); /* and reset it */
  783.         }
  784.         break;
  785.  
  786.       default:
  787.         GetDItem (protoDialog, itemhit, &itemtype, &itemhdl, &itembox);
  788.  
  789.         if (itemtype != ctrlItem + radCtrl)    /* must be radio button */
  790.         fatal ("Not radio button", itemhit);
  791.  
  792.         i = GetCRefCon ((ControlHandle) itemhdl);
  793.  
  794.         if (i == PREF_BLKCHK) {
  795.         dlgbctr = rsserval (itemhit, protoblktbl);
  796.         rshilite (dlgbctr, protoblktbl, protoDialog);
  797.  
  798.         } else if (i == PREF_HNDSHK) {
  799.         dlgturnch = rsserval (itemhit, protohstbl);
  800.         rshilite (dlgturnch, protohstbl, protoDialog);
  801.  
  802.         } else
  803.         printerr ("radio item has bad refcon: ", itemhit);
  804.  
  805.         break;        /* all done with radio buttons */
  806.     }
  807.     }
  808. }                /* protodialog */
  809.  
  810.  
  811.  
  812. #define TR_FIRST TR_AUTOWRAP
  813. #define TR_LAST TR_BLINKC
  814.  
  815. /* extern long mf_sleep_time; */
  816.  
  817. /****************************************************************************/
  818. /****************************************************************************/
  819. termsetdialog ()
  820. {
  821.     DialogPtr termdlg;
  822.     short itemhit;
  823.     short i;
  824.     int dlgint, t_tslice;
  825.     Boolean ts[TR_LAST + 1];
  826.  
  827.     termdlg = GetNewDialog (TERMINALBOXID, NILPTR, (WindowPtr) - 1);
  828.     circleOK(termdlg);
  829.     
  830.     ts[TR_AUTOWRAP] = autowrap;
  831.     ts[TR_AUTOREPT] = autorepeat;
  832.     ts[TR_INVERT] = screeninvert;
  833.     ts[TR_SMOOTH] = smoothscroll;
  834.     ts[TR_AUTOLF] = newline;
  835.     ts[TR_LOCLECHO] = duplex;
  836.     ts[TR_TRANSP] = !transparent;    /* PWP */
  837.     ts[TR_BLOCKC] = blockcursor;
  838.     ts[TR_MOUSE] = mouse_arrows;
  839.     ts[TR_VISBELL] = visible_bell;
  840.     ts[TR_NATCHARS] = nat_chars;
  841.     ts[TR_BLINKC] = blinkcursor;
  842.     /* t_tslice = (int) mf_sleep_time; */
  843.  
  844.     for (;;) {
  845.     /* set the ctl values according to the flags */
  846.     for (i = TR_FIRST; i <= TR_LAST; i++)
  847.         SetCtlValue (getctlhdl (i, termdlg), (ts[i]) ? btnOn : btnOff);
  848.     /* SetNumText(TR_MFSLICE,t_tslice,termdlg); */
  849.  
  850.     ModalDialog (NILPROC, &itemhit);
  851.  
  852.     switch (itemhit) {
  853.       case OKBtn:        /* finish up */
  854.         autowrap = ts[TR_AUTOWRAP];
  855.         autorepeat = ts[TR_AUTOREPT];
  856.         smoothscroll = ts[TR_SMOOTH];
  857.         newline = ts[TR_AUTOLF];
  858.         duplex = ts[TR_LOCLECHO];
  859.         transparent = !ts[TR_TRANSP];
  860.         mouse_arrows = ts[TR_MOUSE];
  861.         visible_bell = ts[TR_VISBELL];
  862.         nat_chars = ts[TR_NATCHARS];
  863.         if ((blockcursor != ts[TR_BLOCKC]) ||
  864.         (blinkcursor != ts[TR_BLINKC])) {
  865.         cursor_erase ();
  866.         blockcursor = ts[TR_BLOCKC];
  867.         blinkcursor = ts[TR_BLINKC];
  868.         cursor_draw ();
  869.         }
  870.         if (screeninvert != ts[TR_INVERT])
  871.         invert_term ();
  872.         /* mf_sleep_time = (long) t_tslice; */
  873.  
  874.       case QuitBtn:    /* fall in from above */
  875.         DisposDialog (termdlg);    /* finished with the dialog */
  876.         return;        /* return */
  877.  
  878.       case TR_RESETBTN:
  879.         consetup();        /* reset the terminal emulator */
  880.         break;
  881.         
  882.       case TR_AUTOWRAP:
  883.       case TR_AUTOREPT:
  884.       case TR_INVERT:
  885.       case TR_SMOOTH:
  886.       case TR_AUTOLF:
  887.       case TR_LOCLECHO:
  888.       case TR_TRANSP:
  889.       case TR_BLOCKC:
  890.       case TR_MOUSE:
  891.       case TR_VISBELL:
  892.       case TR_NATCHARS:
  893.       case TR_BLINKC:
  894.         ts[itemhit] = !ts[itemhit];
  895.         break;
  896.  
  897. #ifdef COMMENT
  898. /* PWP: this field doesn't exist in the dialog. */
  899.       case TR_MFSLICE:
  900.         if (!etgetnum (TR_MFSLICE, termdlg, &dlgint)) {
  901.         SetNumText (TR_MFSLICE, t_tslice, termdlg); /* and reset it */
  902.         } else {
  903.         t_tslice = dlgint;
  904.         }
  905.         break;
  906. #endif
  907.     }
  908.     }
  909. }                /* termsetdialog */
  910.  
  911.  
  912.  
  913. /****************************************************************************/
  914. /****************************************************************************/
  915. setradpair (rid1, rid2, bool, dlg)
  916. DialogPtr dlg;
  917. {
  918.     SetCtlValue (getctlhdl (rid1, dlg), bool ? btnOn : btnOff);
  919.     SetCtlValue (getctlhdl (rid2, dlg), bool ? btnOff : btnOn);
  920. }                /* setradpair */
  921.  
  922.  
  923.  
  924. /****************************************************************************/
  925. /* setfiledialog - enter file settings dialog. */
  926. /****************************************************************************/
  927. setfiledialog ()
  928. {
  929.     DialogPtr setfdlg;
  930.     short item = RADITM_FIRST - 1;
  931.  
  932.     setfdlg = GetNewDialog (FILEBOXID, NILPTR, (WindowPtr) - 1);
  933.     circleOK(setfdlg);
  934.     filargs.filflg = filargs.fildflg;    /* use current defaults */
  935.  
  936.     for (;;) {
  937.     setfilflgs (item, setfdlg);    /* keep flags upto date */
  938.  
  939.     setradpair (FSET_ATTEND, FSET_UNATTEND,
  940.             (filargs.filflg & FIL_DODLG), setfdlg);
  941.     setradpair (FSET_SUPERSEDE, FSET_NEWNAMES,
  942.             (filargs.filflg & FIL_OKILL), setfdlg);
  943.     SetCtlValue (getctlhdl (FSET_KEEP, setfdlg),
  944.              (keep) ? btnOn : btnOff);
  945.  
  946.     ModalDialog (NILPROC, &item);
  947.     switch (item) {
  948.       case ok:
  949.         filargs.fildflg = filargs.filflg;    /* set default flags */
  950.  
  951.       case cancel:
  952.         DisposDialog (setfdlg);    /* all done with dialog */
  953.         return;        /* can go home... */
  954.  
  955.       case FSET_ATTEND:
  956.       case FSET_UNATTEND:
  957.         filargs.filflg ^= FIL_DODLG;    /* toggle flag */
  958.         break;
  959.  
  960.       case FSET_SUPERSEDE:
  961.       case FSET_NEWNAMES:
  962.         filargs.filflg ^= FIL_OKILL;    /* toggle flag */
  963.         break;
  964.  
  965.       case FSET_KEEP:
  966.         keep = !keep;
  967.         break;
  968.     }
  969.     }
  970. }                /* setfiledialog */
  971.  
  972.  
  973.  
  974. struct launchparams {
  975.     char *lnamep;
  976.     short config;
  977. }   lparams;
  978. char lfile[64];
  979.  
  980.  
  981.  
  982. /****************************************************************************/
  983. /* handlelaunch - Handle transfer to another application. */
  984. /*                Called when "launch" selected from menu bar. */
  985. /****************************************************************************/
  986. handlelaunch ()
  987. {
  988.     OSType appltype = 'APPL';
  989.     Point where;
  990.     SFReply sfr;
  991.  
  992.     SetPt (&where, 75, 115);
  993.     SFGetFile (&where, "", NILPROC, 1, &appltype, NILPROC, &sfr);
  994.  
  995.     if (!sfr.good)        /* hit cancel, return now */
  996.     return;
  997.  
  998.     p2cstr (&sfr.fName);
  999.  
  1000.     mac_cleanup ();        /* about to leave, leave clean! */
  1001.  
  1002.     strcpy (lfile, &sfr.fName);
  1003.     lparams.lnamep = lfile;
  1004.     lparams.config = 0;
  1005.     SetVol ((char *) 0, sfr.vRefNum);    /* allow any drive */
  1006.     c2pstr (lparams.lnamep);
  1007.  
  1008.     loadA0 (&lparams);
  1009.     Launch ();
  1010. }                /* handlelaunch */
  1011.  
  1012.  
  1013.  
  1014. /****************************************************************************/
  1015. /****************************************************************************/
  1016. fstats ()
  1017. {
  1018. }                /* fstats */
  1019.  
  1020.  
  1021.  
  1022. /****************************************************************************/
  1023. /****************************************************************************/
  1024. tstats ()
  1025. {
  1026. }                /* tstats */
  1027.  
  1028.  
  1029.  
  1030. /****************************************************************************/
  1031. /****************************************************************************/
  1032. rdebu (c)
  1033. int c;
  1034. {
  1035. }                /* rdebu */
  1036.  
  1037.  
  1038.  
  1039. /****************************************************************************/
  1040. /****************************************************************************/
  1041. sdebu (l)
  1042. int l;
  1043. {
  1044. }                /* sdebu */
  1045.