home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume18 / mush / part21 < prev    next >
Internet Message Format  |  1991-04-22  |  51KB
  1. From: argv@zipcode.com (Dan Heller)
  2. Newsgroups: comp.sources.misc
  3. Subject: v18i078:  mush - Mail User's Shell, Part21/22
  4. Message-ID: <1991Apr22.153932.380@sparky.IMD.Sterling.COM>
  5. Date: 22 Apr 91 15:39:32 GMT
  6. Approved: kent@sparky.imd.sterling.com
  7. X-Checksum-Snefru: 80edc9a2 631f45a7 27f6cee2 bfdb090f
  8.  
  9. Submitted-by: Dan Heller <argv@zipcode.com>
  10. Posting-number: Volume 18, Issue 78
  11. Archive-name: mush/part21
  12. Supersedes: mush: Volume 12, Issue 28-47
  13.  
  14. #!/bin/sh
  15. # do not concatenate these parts, unpack them in order with /bin/sh
  16. # file signals.c continued
  17. #
  18. if test ! -r _shar_seq_.tmp; then
  19.     echo 'Please unpack part 1 first!'
  20.     exit 1
  21. fi
  22. (read Scheck
  23.  if test "$Scheck" != 21; then
  24.     echo Please unpack part "$Scheck" next!
  25.     exit 1
  26.  else
  27.     exit 0
  28.  fi
  29. ) < _shar_seq_.tmp || exit 1
  30. if test ! -f _shar_wnt_.tmp; then
  31.     echo 'x - still skipping signals.c'
  32. else
  33. echo 'x - continuing file signals.c'
  34. sed 's/^X//' << 'SHAR_EOF' >> 'signals.c' &&
  35. X    (void) fprintf(stderr, "%s: %s\n", prog_name,
  36. X    (sig == SIGSEGV)? "Segmentation violation": "Bus error");
  37. X    cleanup(sig);
  38. }
  39. SHAR_EOF
  40. echo 'File signals.c is complete' &&
  41. chmod 0644 signals.c ||
  42. echo 'restore of signals.c failed'
  43. Wc_c="`wc -c < 'signals.c'`"
  44. test 12425 -eq "$Wc_c" ||
  45.     echo 'signals.c: original size 12425, current size' "$Wc_c"
  46. rm -f _shar_wnt_.tmp
  47. fi
  48. # ============= sort.c ==============
  49. if test -f 'sort.c' -a X"$1" != X"-c"; then
  50.     echo 'x - skipping sort.c (File already exists)'
  51.     rm -f _shar_wnt_.tmp
  52. else
  53. > _shar_wnt_.tmp
  54. echo 'x - extracting sort.c (Text)'
  55. sed 's/^X//' << 'SHAR_EOF' > 'sort.c' &&
  56. /* sort.c 3.0    (c) copyright 1986,1990 (Dan Heller) */
  57. X
  58. #include "mush.h"
  59. /* #define MYQSORT */
  60. X
  61. /* The size of this array should really be bounded by
  62. X * 2 spaces for each possible different sort criteria
  63. X * (one space for each key letter and one per for 'r'),
  64. X * but 16 leaves room to add to the current list.
  65. X */
  66. static char subsort[16];
  67. X
  68. static int depth, order, ignore_case;
  69. static jmp_buf sortbuf;
  70. X
  71. sort(argc, argv, list)
  72. register int argc;
  73. register char *argv[], list[];
  74. {
  75. X    int msg_cmp();
  76. X    SIGRET (*oldint)(), (*oldquit)();
  77. X    int n, offset = -1, range = 0;
  78. X    long curr_msg_off = msg[current_msg].m_offset;
  79. X
  80. X    depth = 0, order = 1, ignore_case = FALSE;
  81. X
  82. X    while (argc && *++argv) {
  83. X    n = (argv[0][0] == '-' && argv[0][1] != 0);
  84. X    while (argv[0][n]) {
  85. X        if (depth > sizeof subsort - 2)
  86. X        break;
  87. X        switch(argv[0][n]) {
  88. X        case '-': /* reverse order of next criteria (obsolete) */
  89. X            argv[0][n] = 'r'; /* fix it and fall through */
  90. X        case 'r': /* reverse order of next criteria */
  91. X        case 'd': /* sort by date */
  92. X        case 'a': /* sort by author (address) */
  93. X        case 's': /* sort by subject (ignore Re:) */
  94. X        case 'R': /* sort by subject including Re: */
  95. X        case 'l': /* sort by length in bytes */
  96. X        case 'S': /* sort by message status */
  97. X        case 'p': /* sort by message priority */
  98. X            /* skip consecutive repeats of the same flag */
  99. X            if (depth < 1 || subsort[depth-1] != argv[0][n])
  100. X            subsort[depth++] = argv[0][n];
  101. X        when 'i': ignore_case = TRUE;
  102. X        otherwise: return help(0, "sort", cmd_help);
  103. X        }
  104. X        n++;
  105. X    }
  106. X    }
  107. X    if (depth == 0 || subsort[depth-1] == 'r')
  108. X    subsort[depth++] = 'S'; /* status sort is the default */
  109. X    subsort[depth] = 0;
  110. X    depth = 0;    /* start at the beginning */
  111. X    if (msg_cnt <= 1) {
  112. X    print("Not enough messages to sort.\n");
  113. X    return -1;
  114. X    }
  115. X    turnon(glob_flags, IGN_SIGS);
  116. X    on_intr();
  117. X
  118. X    if (list && ison(glob_flags, IS_PIPE)) {
  119. X    int consec = 1;
  120. X    for (n = 0; n < msg_cnt; n++)
  121. X        if (msg_bit(list, n)) {
  122. X        if (!consec) {
  123. X            ok_box("Listed messages not consecutive\n");
  124. X            turnoff(glob_flags, IGN_SIGS);
  125. X            off_intr();
  126. X            return -1;
  127. X        }
  128. X        if (offset < 0)
  129. X            offset = n;
  130. X        range++;
  131. X        } else if (offset >= 0)
  132. X        consec = 0;
  133. X    } else
  134. X    offset = 0, range = msg_cnt;
  135. X
  136. X    if (range < 2)
  137. X    print("Range not broad enough to sort anything\n");
  138. X    else {
  139. X    Debug("Sorting %d messages starting at message %d\n", range, offset+1);
  140. X
  141. X    if (setjmp(sortbuf) == 0)
  142. X        qsort((char *)&msg[offset], range, sizeof (struct msg), msg_cmp);
  143. X    else
  144. X        print("WARNING: Sorting interrupted: unpredictable order.\n");
  145. X    turnon(glob_flags, DO_UPDATE);
  146. X    }
  147. X    for (n = 0; n < msg_cnt; n++)
  148. X    if (msg[n].m_offset == curr_msg_off)
  149. X        break;
  150. X    current_msg = n;
  151. X    turnoff(glob_flags, IGN_SIGS);
  152. X    off_intr();
  153. X    /* Break pipes because message lists are invalid */
  154. X    return 0 - in_pipe();
  155. }
  156. X
  157. #ifdef MYQSORT
  158. qsort(base, len, siz, compar)
  159. register struct msg *base;
  160. int (*compar)();
  161. {
  162. X     register int i, swapping;
  163. X     struct msg temp;
  164. X
  165. X     do  {
  166. X     swapping = 0;
  167. X     for (i = 0; i < len-1; ++i) {
  168. X         if (compar(base+i, base+i+1) > 0) {
  169. X         temp = base[i];
  170. X         base[i] = base[i+1];
  171. X         base[i+1] = temp;
  172. X         swapping = 1;
  173. X         }
  174. X     }
  175. X     } while (swapping);
  176. }
  177. #endif /* MYSORT */
  178. X
  179. status_cmp(msg1, msg2)
  180. register struct msg *msg1, *msg2;
  181. {
  182. X    if (msg1->m_flags == msg2->m_flags)
  183. X    return msg_cmp(msg1, msg2);
  184. X    if (ison(msg1->m_flags, DELETE) && isoff(msg2->m_flags, DELETE))
  185. X    return order;
  186. X    if (isoff(msg1->m_flags, DELETE) && ison(msg2->m_flags, DELETE))
  187. X    return -order;
  188. X    if (isoff(msg1->m_flags, OLD) && ison(msg2->m_flags, OLD))
  189. X    return -order;
  190. X    if (ison(msg1->m_flags, OLD) && isoff(msg2->m_flags, OLD))
  191. X    return order;
  192. X    if (ison(msg1->m_flags, UNREAD) && isoff(msg2->m_flags, UNREAD))
  193. X    return -order;
  194. X    if (isoff(msg1->m_flags, UNREAD) && ison(msg2->m_flags, UNREAD))
  195. X    return order;
  196. X    if (ison(msg1->m_flags,PRESERVE) && isoff(msg2->m_flags,PRESERVE))
  197. X    return -order;
  198. X    if (isoff(msg1->m_flags,PRESERVE) && ison(msg2->m_flags,PRESERVE))
  199. X    return order;
  200. X    if (ison(msg1->m_flags,REPLIED) && isoff(msg2->m_flags,REPLIED))
  201. X    return -order;
  202. X    if (isoff(msg1->m_flags,REPLIED) && ison(msg2->m_flags,REPLIED))
  203. X    return order;
  204. X    if (ison(msg1->m_flags,SAVED) && isoff(msg2->m_flags,SAVED))
  205. X    return -order;
  206. X    if (isoff(msg1->m_flags,SAVED) && ison(msg2->m_flags,SAVED))
  207. X    return order;
  208. X    if (ison(msg1->m_flags,PRINTED) && isoff(msg2->m_flags,PRINTED))
  209. X    return -order;
  210. X    if (isoff(msg1->m_flags,PRINTED) && ison(msg2->m_flags,PRINTED))
  211. X    return order;
  212. X    if (ison(msg1->m_flags,FORWARD) && isoff(msg2->m_flags,FORWARD))
  213. X    return -order;
  214. X    if (isoff(msg1->m_flags,FORWARD) && ison(msg2->m_flags,FORWARD))
  215. X    return order;
  216. X
  217. X    return pri_cmp(msg1, msg2);
  218. }
  219. X
  220. author_cmp(msg1, msg2)
  221. register struct msg *msg1, *msg2;
  222. {
  223. X    char buf1[HDRSIZ], buf2[HDRSIZ];
  224. X    int retval;
  225. X
  226. X    (void) reply_to(msg1 - msg, 0, buf1); /* "0" for "author only" */
  227. X    (void) reply_to(msg2 - msg, 0, buf2);
  228. X    Debug("author: msg %d: %s, msg %d: %s\n", msg1-msg, buf1, msg2-msg, buf2);
  229. X    if (ignore_case)
  230. X    retval = lcase_strncmp(buf1, buf2, -1) * order;
  231. X    else
  232. X    retval = strcmp(buf1, buf2) * order;
  233. X    return retval ? retval : msg_cmp(msg1, msg2);
  234. }
  235. X
  236. /* compare messages according to size (length) */
  237. size_cmp(msg1, msg2)
  238. register struct msg *msg1, *msg2;
  239. {
  240. X    int retval;
  241. X
  242. X    Debug("sizes: (%d): %d, (%d): %d\"\n",
  243. X    msg1-msg, msg1->m_size, msg2-msg, msg2->m_size);
  244. X    if (retval = (msg1->m_size - msg2->m_size) * order) /* assign and test */
  245. X    return retval;
  246. X    return msg_cmp(msg1, msg2);
  247. }
  248. X
  249. /*
  250. X * Subject comparison ignoring Re:  subject_to() appends an Re: if there is
  251. X * any subject whatsoever.
  252. X */
  253. subject_cmp(msg1, msg2)
  254. register struct msg *msg1, *msg2;
  255. {
  256. X    char buf1[HDRSIZ], buf2[HDRSIZ];
  257. X    register char *p1, *p2;
  258. X    int retval;
  259. X
  260. X    p1 = subject_to(msg1 - msg, buf1);
  261. X    p2 = subject_to(msg2 - msg, buf2);
  262. X    if (p1) {
  263. X    p1 += 4;
  264. X    while (isspace(*p1))
  265. X        p1++;
  266. X    } else
  267. X    p1 = buf1; /* subject_to() makes it an empty string */
  268. X    if (p2) {
  269. X    p2 += 4;
  270. X    while (isspace(*p2))
  271. X        p2++;
  272. X    } else
  273. X    p2 = buf2; /* subject_to() makes it an empty string */
  274. X    Debug("subjects: (%d): \"%s\" (%d): \"%s\"\n", msg1-msg, p1, msg2-msg, p2);
  275. X    if (ignore_case)
  276. X    retval = lcase_strncmp(p1, p2, -1) * order;
  277. X    else
  278. X    retval = strcmp(p1, p2) * order;
  279. X    return retval ? retval : msg_cmp(msg1, msg2);
  280. }
  281. X
  282. /*
  283. X * compare subject strings from two messages.
  284. X * If Re is appended, so be it -- if user wants to ignore Re: use 'R' flag.
  285. X */
  286. subj_with_re(msg1, msg2)
  287. register struct msg *msg1, *msg2;
  288. {
  289. X    char buf1[HDRSIZ], buf2[HDRSIZ], *p;
  290. X    int retval;
  291. X
  292. X    if (!(p = header_field(msg1 - msg, "subject")))
  293. X    p = "";
  294. X    (void) strcpy(buf1, p);
  295. X    if (!(p = header_field(msg2 - msg, "subject")))
  296. X    p = "";
  297. X    (void) strcpy(buf2, p);
  298. X    Debug("subjects: (%d): \"%s\" (%d): \"%s\"\n",
  299. X    msg1-msg, buf1, msg2-msg, buf2);
  300. X    if (ignore_case)
  301. X    retval = lcase_strncmp(buf1, buf2, -1) * order;
  302. X    else
  303. X    retval = strcmp(buf1, buf2) * order;
  304. X    return retval ? retval : msg_cmp(msg1, msg2);
  305. }
  306. X
  307. date_cmp(msg1, msg2)
  308. register struct msg *msg1, *msg2;
  309. {
  310. X    long tm1, tm2;
  311. X
  312. X    if (ison(glob_flags, DATE_RECV)) {
  313. X    (void) sscanf(msg1->m_date_recv, "%ld", &tm1);
  314. X    (void) sscanf(msg2->m_date_recv, "%ld", &tm2);
  315. X    } else {
  316. X    (void) sscanf(msg1->m_date_sent, "%ld", &tm1);
  317. X    (void) sscanf(msg2->m_date_sent, "%ld", &tm2);
  318. X    }
  319. X    return tm1 < tm2 ? -order : (tm1 > tm2) ? order : msg_cmp(msg1, msg2);
  320. }
  321. X
  322. pri_cmp(msg1, msg2)
  323. register struct msg *msg1, *msg2;
  324. {
  325. X    int i;
  326. X    u_long pr1 = 0, pr2 = 0;
  327. X
  328. X    for (i = 0; pr1 == pr2 && i <= MAX_PRIORITY; i++) {
  329. X    if (ison(msg1->m_flags, M_PRIORITY(i)))
  330. X        turnon(pr1, ULBIT(i));
  331. X    if (ison(msg2->m_flags, M_PRIORITY(i)))
  332. X        turnon(pr2, ULBIT(i));
  333. X    }
  334. X    return pr1 > pr2 ? -order : (pr1 < pr2) ? order : msg_cmp(msg1, msg2);
  335. }
  336. X
  337. static
  338. msg_cmp(msg1, msg2)
  339. register struct msg *msg1, *msg2;
  340. {
  341. X    int sv_order = order, sv_depth = depth, retval = 0;
  342. X
  343. X    if (ison(glob_flags, WAS_INTR))
  344. X    longjmp(sortbuf, 1);
  345. X    if (msg1 < msg || msg2 < msg) {
  346. X    wprint("sort botch trying to sort %d and %d using %s\n",
  347. X        msg1-msg, msg2-msg, subsort);
  348. X    return 0;
  349. X    }
  350. X
  351. X    if (subsort[depth] == 'r') {
  352. X    order = -1;
  353. X    depth++;
  354. X    } else
  355. X    order = 1;
  356. X    switch(subsort[depth++]) {
  357. X    case '\0': retval = 0;
  358. X    when 'd': retval = date_cmp(msg1, msg2);
  359. X    when 'a': retval = author_cmp(msg1, msg2);
  360. X    when 's': retval = subject_cmp(msg1, msg2);
  361. X    when 'R': retval = subj_with_re(msg1, msg2);
  362. X    when 'l': retval = size_cmp(msg1, msg2); /* length compare */
  363. X    when 'p': retval = pri_cmp(msg1, msg2);
  364. X    otherwise: retval = status_cmp(msg1, msg2);
  365. X    }
  366. X    depth = sv_depth;
  367. X    order = sv_order;
  368. X    return retval;
  369. }
  370. SHAR_EOF
  371. chmod 0644 sort.c ||
  372. echo 'restore of sort.c failed'
  373. Wc_c="`wc -c < 'sort.c'`"
  374. test 8699 -eq "$Wc_c" ||
  375.     echo 'sort.c: original size 8699, current size' "$Wc_c"
  376. rm -f _shar_wnt_.tmp
  377. fi
  378. # ============= strings.c ==============
  379. if test -f 'strings.c' -a X"$1" != X"-c"; then
  380.     echo 'x - skipping strings.c (File already exists)'
  381.     rm -f _shar_wnt_.tmp
  382. else
  383. > _shar_wnt_.tmp
  384. echo 'x - extracting strings.c (Text)'
  385. sed 's/^X//' << 'SHAR_EOF' > 'strings.c' &&
  386. /* strings.c Copyright(1988) Dan Heller */
  387. X
  388. #include "mush.h"
  389. X
  390. /*
  391. X * reverse a string.  Useful for uucp-style address comparisons.
  392. X */
  393. char *
  394. reverse(s)
  395. char s[];
  396. {
  397. X    int n = strlen(s), m;
  398. X    char c;
  399. X
  400. X    if (n < 1)
  401. X    return 0;
  402. X    if (n & 1)
  403. X    n = n/2 + 1, m = n - 2;
  404. X    else
  405. X    n /= 2, m = n - 1;
  406. X    for ( ; m >= 0; m--, n++)
  407. X    c = s[n], s[n] = s[m], s[m] = c;
  408. X    return s;
  409. }
  410. X
  411. /*
  412. X * lose the newline character, trailing whitespace, and return the end of p
  413. X * test for '\n' separately since some _ctype_[] arrays may not have the
  414. X * _S bit set for the newline character.  see <ctype.h> for more info.
  415. X */
  416. char *
  417. no_newln(p)
  418. register char *p;
  419. {
  420. X    register char *p2 = p + strlen(p);    /* point it to the null terminator */
  421. X
  422. X    while (p2 > p && *--p2 == '\n' || isspace(*p2))
  423. X    *p2 = 0;  /* get rid of newline and trailing spaces */
  424. X    return p2;
  425. }
  426. X
  427. /* find any character in s1 that's in s2; return pointer to char in s1. */
  428. char *
  429. any(s1, s2)
  430. register char *s1, *s2;
  431. {
  432. X    register char *p;
  433. X    if (!s1 || !*s1 || !s2 || !*s2)
  434. X    return NULL;
  435. X    for( ; *s1; s1++) {
  436. X    for(p = s2; *p; p++)
  437. X        if (*p == *s1)
  438. X        return s1;
  439. X    }
  440. X    return NULL;
  441. }
  442. X
  443. /* check two lists of strings each of which contain substrings.
  444. X * Each substring is delimited by any char in "delimiters"
  445. X * return true if any elements in list1 are on list2.
  446. X * thus:
  447. X * string1 = "foo, bar, baz"
  448. X * string2 = "foobar, baz, etc"
  449. X * delimiters = ", \t"
  450. X * example returns 1 because "baz" exists in both lists
  451. X * NOTE: case is ignored.
  452. X */
  453. chk_two_lists(list1, list2, delimiters)
  454. register char *list1, *list2, *delimiters;
  455. {
  456. X    register char *p, c;
  457. X    register int found = 0;
  458. X
  459. X    if (!list1 || !list2)
  460. X    return 0;
  461. X
  462. X    if (p = any(list1, delimiters)) {
  463. X    if (p > list1) {
  464. X        c = *p; *p = 0;
  465. X        /* Check list2 against the first word of list1.
  466. X         * Swap places of list2 and list1 to step through list2.
  467. X         */
  468. X        found = chk_two_lists(list2, list1, delimiters);
  469. X        *p = c;
  470. X    }
  471. X    if (found)
  472. X        return 1;
  473. X    for (p++; *p && index(delimiters, *p); p++)
  474. X        ;
  475. X    if (!*p)
  476. X        return 0;
  477. X    } else if (!any(list2, delimiters))
  478. X    /* Do the trivial case of single words */
  479. X    return !lcase_strncmp(list1, list2, -1);
  480. X    else
  481. X    p = list1;
  482. X
  483. X    /* Either only list2 has delims or the first word of list1
  484. X     * did not match anything in list2.  Check list2 against the
  485. X     * rest of list1.  This could be more efficient by using a
  486. X     * different function to avoid repeating the any() calls.
  487. X     */
  488. X    return chk_two_lists(list2, p, delimiters);
  489. }
  490. X
  491. bzero(addr, size)
  492. register char *addr;
  493. register int size;
  494. {
  495. X    while (size-- > 0)
  496. X    addr[size] = 0;
  497. }
  498. X
  499. /* do an atoi() on the string passed and return in "val" the decimal value.
  500. X * the function returns a pointer to the location in the string that is not
  501. X * a digit.
  502. X */
  503. char *
  504. my_atoi(p, val)
  505. register char *p;
  506. register int *val;
  507. {
  508. X    int positive = 1;
  509. X
  510. X    if (!p)
  511. X    return NULL;
  512. X    *val = 0;
  513. X    if (*p == '-')
  514. X    positive = -1, p++;
  515. X    while (isdigit(*p))
  516. X    *val = (*val) * 10 + *p++ - '0';
  517. X    *val *= positive;
  518. X    return p;
  519. }
  520. X
  521. /* strcmp ignoring case */
  522. lcase_strncmp(str1, str2, n)
  523. register char *str1, *str2;
  524. {
  525. X    while (*str1 && *str2 && --n != 0)
  526. X    if (lower(*str1) != lower(*str2))
  527. X        break;
  528. X    else
  529. X        str1++, str2++;
  530. X    return lower(*str1) - lower(*str2);
  531. }
  532. X
  533. /* strcpy converting everything to lower case (arbitrary) to ignore cases */
  534. char *
  535. lcase_strcpy(dst, src)
  536. register char *dst, *src;
  537. {
  538. X    register char *s = dst;
  539. X
  540. X    /* "lower" is a macro, don't increment its argument! */
  541. X    while (*dst++ = lower(*src))
  542. X    src++;
  543. X    return s;
  544. }
  545. X
  546. /* this strcpy returns number of bytes copied */
  547. Strcpy(dst, src)
  548. register char *dst, *src;
  549. {
  550. X    register int n = 0;
  551. X    if (!dst || !src)
  552. X    return 0;
  553. X    while (*dst++ = *src++)
  554. X    n++;
  555. X    return n;
  556. }
  557. X
  558. char *
  559. savestr(s)
  560. register char *s;
  561. {
  562. X    register char *p;
  563. X
  564. X    if (!s)
  565. X    s = "";
  566. X    if (!(p = malloc((unsigned) (strlen(s) + 1)))) {
  567. X    error("out of memory saving %s", s);
  568. X    return NULL;
  569. X    }
  570. X    return strcpy(p, s);
  571. }
  572. X
  573. /* copy a vector of strings into one string -- return the end of the string */
  574. char *
  575. argv_to_string(p, argv)
  576. register char *p, **argv;
  577. {
  578. X    register int i;
  579. X    register char *ptr = p;
  580. X
  581. X    *p = 0;
  582. X    if (!argv[0])
  583. X    return "";
  584. X    for (i = 0; argv[i]; i++)
  585. X    ptr += strlen(sprintf(ptr, "%s ", argv[i]));
  586. X    *--ptr = 0;   /* get rid of the last space */
  587. X    return ptr;
  588. }
  589. X
  590. char *
  591. itoa(n)
  592. {
  593. X    static char buf[10];
  594. X    return sprintf(buf, "%d", n);
  595. }
  596. X
  597. /*
  598. X * There are two different kinds of sprintf() --those that return char * and
  599. X * those that return int.  System-V returns int (the length of the resulting
  600. X * string).  BSD has historically returned a pointer to the resulting string
  601. X * instead. Mush was originally written under BSD, so the usage has always
  602. X * been to assume the char * method.  Because the system-v method is far more
  603. X * useful, mush should some day change to use that method, but until then,
  604. X * this routine was written to allow all the unix'es to appear the same to
  605. X * the programmer regardless of which sprintf is actually used.  The "latest"
  606. X * version of 4.3BSD (as of Fall 1988) has changed its format to go from the
  607. X * historical BSD method to the sys-v method.  It is no longer possible to
  608. X * simply #ifdef this routine for sys-v --it is now required to use this
  609. X * routine regardless of which sprintf is notice to your machine.  However,
  610. X * if you know your system's sprintf returns a char *, you can remove the
  611. X * define in strings.h
  612. X */
  613. #include <varargs.h>
  614. /*VARARGS*/
  615. /*ARGSUSED*/
  616. char *
  617. Sprintf(va_alist)
  618. va_dcl
  619. {
  620. X    char *buf, *fmt;
  621. X    va_list ap;
  622. X
  623. X    va_start(ap);
  624. X    buf = va_arg(ap, char *);
  625. X    fmt = va_arg(ap, char *);
  626. #ifdef VPRINTF
  627. X    (void) vsprintf(buf, fmt, ap);
  628. #else
  629. X    {
  630. X    FILE foo;
  631. X    foo._cnt = BUFSIZ;
  632. X    foo._base = foo._ptr = buf; /* may have to be cast (unsigned char *) */
  633. X    foo._flag = _IOWRT+_IOSTRG;
  634. X    (void) _doprnt(fmt, ap, &foo);
  635. X    *foo._ptr = '\0'; /* plant terminating null character */
  636. X    }
  637. #endif /* VPRINTF */
  638. X    va_end(ap);
  639. X    return buf;
  640. }
  641. X
  642. void
  643. print_argv(argv)
  644. char **argv;
  645. {
  646. X    while (*argv)
  647. X    if (debug)
  648. X        wprint("(%s) ", *argv++);
  649. X    else
  650. X        wprint("%s ", *argv++);
  651. X    wprint("\n");
  652. }
  653. X
  654. /*
  655. X * putstring -- put a string into a file.  Expand \t's into tabs and \n's
  656. X * into newlines.  Append a \n and fflush(fp);
  657. X */
  658. void
  659. putstring(p, fp)
  660. register char *p;
  661. register FILE *fp;
  662. {
  663. X    for ( ; *p; ++p)
  664. X    if (*p != '\\')
  665. X        (void) fputc(*p, fp);
  666. X    else
  667. X        switch(*++p) {
  668. X        case 'n': (void) fputc('\n', fp);
  669. X        when 't': (void) fputc('\t', fp);
  670. X        otherwise: (void) fputc(*p, fp);
  671. X        }
  672. X    (void) fputc('\n', fp);
  673. X    (void) fflush(fp);
  674. }
  675. X
  676. #define chtoi(c)    ((int)(c) - (int)'0')
  677. X
  678. /* m_xlate(str) converts strings of chars which contain ascii representations
  679. X *  of control characters appearing in str into the literal characters they
  680. X *  represent.  The usual curses-mode character expansions (\Cx -> control-x)
  681. X *  are honored, as are most C escapes.  Unrecognized portions are unchanged.
  682. X */
  683. char *
  684. m_xlate (str)
  685. register char *str;
  686. {
  687. X    register char *r, *s, *t;
  688. X    int dv, nd;
  689. X
  690. X    /*
  691. X     * r will receive the new string, s will track the old one,
  692. X     *  and t will step through escape sequences
  693. X     * This allows the translation to be done in place
  694. X     */
  695. X    r = s = str;
  696. X    while (s && *s) {
  697. X    if (*s == '\\') {
  698. X        t = s + 1;
  699. X        /*
  700. X         * After each case below, t should point to the character
  701. X         *  following the escape sequence
  702. X         */
  703. X        switch(*t) {
  704. X        case '\0' :
  705. X            /*
  706. X             * Hmmm ... a backslash followed by the string
  707. X             *  terminator.  Copy the backslash ONLY.
  708. X             */
  709. X            *r++ = *s++;
  710. X            break;
  711. X        case '0' :
  712. X        case '1' :
  713. X        case '2' :
  714. X        case '3' :
  715. X        case '4' :
  716. X        case '5' :
  717. X        case '6' :
  718. X        case '7' :
  719. X            /*
  720. X             * Convert up to 3 octal digits to their ascii value
  721. X             */
  722. X            dv = chtoi(*t++);
  723. X            for (nd = 0; (isdigit(*t) && (nd < 2)); nd++)
  724. X            if (chtoi(*t) < 8)
  725. X                dv = (8 * dv) + chtoi(*t++);
  726. X            else
  727. X                break;
  728. X            if (dv < 256 && dv > 0)
  729. X            /* Valid octal number escaped */
  730. X            *r++ = (char)dv;
  731. X            else
  732. X            /* Invalid octal number, so copy unchanged */
  733. X            while (s < t)
  734. X                *r++ = *s++;
  735. X            break;
  736. X        case 'b' :
  737. X            *r++ = '\b';
  738. X            t++;
  739. X            break;
  740. X        case 'C' :
  741. X            t++;
  742. X            if (*t == '?')
  743. X            *r++ = '\177';
  744. X            else if (*t == '~')
  745. X            *r++ = '\036';
  746. X            else if (*t == '/')
  747. X            *r++ = '\037';
  748. X            else if (isalpha(*t) || *t > '\132' && *t < '\140')
  749. X            *r++ = *t & 037;
  750. X            else
  751. X            while (s <= t) *r++ = *s++;
  752. X            t++;
  753. X            break;
  754. X        case 'E' :
  755. X            *r++ = '\033';
  756. X            t++;
  757. X            break;
  758. X        case 'f' :
  759. X            *r++ = '\f';
  760. X            t++;
  761. X            break;
  762. X        case 'n' :
  763. X            *r++ = '\n';
  764. X            t++;
  765. X            break;
  766. X        case 'r' :
  767. X            *r++ = '\r';
  768. X            t++;
  769. X            break;
  770. X        case 't' :
  771. X            *r++ = '\t';
  772. X            t++;
  773. X            break;
  774. X        case '\\' :
  775. X            *r++ = *t++;
  776. X            break;
  777. X        default :
  778. X            /*
  779. X             * Not recognized, so copy both characters
  780. X             */
  781. X            *r++ = *s++;
  782. X            *r++ = *s++;
  783. X            break;
  784. X        }
  785. X        /*
  786. X         * Now make sure s also points to the character after the
  787. X         *  escape sequence, by comparing to t
  788. X         */
  789. X        if (t > s)
  790. X        s = t;
  791. X    } else
  792. X        *r++ = *s++;
  793. X    }
  794. X    *r = '\0';
  795. X    return str;
  796. }
  797. X
  798. /*
  799. X * Convert control characters to ascii format (reverse effect of m_xlate()).
  800. X */
  801. char *
  802. ctrl_strcpy(s_out, s_in, bind_format)
  803. register char *s_out, *s_in;
  804. {
  805. #if !defined(M_XENIX) || (defined(M_XENIX) && !defined(CURSES))
  806. X    extern char *_unctrl[];
  807. #endif /* !M_XENIX || M_XENIX && !CURSES */
  808. X    char *start = s_out;
  809. X
  810. X    for (; *s_in; s_in++)
  811. X    if (*s_in == '\n')
  812. X        *s_out++ = '\\', *s_out++ = 'n';
  813. X    else if (*s_in == '\r')
  814. X        *s_out++ = '\\', *s_out++ = 'r';
  815. X    else if (*s_in == '\t')
  816. X        *s_out++ = '\\', *s_out++ = 't';
  817. X    else if (*s_in == ESC)
  818. X        *s_out++ = '\\', *s_out++ = 'E';
  819. X    else if (iscntrl(*s_in)) {
  820. X        if (bind_format)
  821. X        *s_out++ = '\\', *s_out++ = 'C';
  822. X        else
  823. X        *s_out++ = '^';
  824. X        *s_out++ = _unctrl[*s_in][1];
  825. X    } else
  826. X        *s_out++ = *s_in;
  827. X    *s_out = 0;
  828. X    return start;
  829. }
  830. X
  831. /*
  832. X * This routine returns a pointer to the file portion of a path/file name.
  833. X */
  834. char *
  835. basename(path)
  836. register char *path;
  837. {
  838. X    char *file;
  839. X
  840. X    if (file = rindex(path, '/'))
  841. X    return ++file;
  842. X    return path;
  843. }
  844. SHAR_EOF
  845. chmod 0644 strings.c ||
  846. echo 'restore of strings.c failed'
  847. Wc_c="`wc -c < 'strings.c'`"
  848. test 10202 -eq "$Wc_c" ||
  849.     echo 'strings.c: original size 10202, current size' "$Wc_c"
  850. rm -f _shar_wnt_.tmp
  851. fi
  852. # ============= strings.h ==============
  853. if test -f 'strings.h' -a X"$1" != X"-c"; then
  854.     echo 'x - skipping strings.h (File already exists)'
  855.     rm -f _shar_wnt_.tmp
  856. else
  857. > _shar_wnt_.tmp
  858. echo 'x - extracting strings.h (Text)'
  859. sed 's/^X//' << 'SHAR_EOF' > 'strings.h' &&
  860. /* @(#)strings.h    (c) copyright 9/3/86 (Dan Heller) */
  861. X
  862. /*
  863. X * If you *know* your sprintf() returns char*, you can remove the follow
  864. X * define.  Careful, "new" 4.3BSD's sprintf returns int.  See README
  865. X */
  866. #define sprintf Sprintf
  867. #ifdef SYSV
  868. #define    index    strchr
  869. #define    rindex    strrchr
  870. #endif /* SYSV */
  871. X
  872. /* External function definitions for routines described in string(3).  */
  873. extern char
  874. X    *strcat(), *strncat(), *strcpy(), *strncpy(),
  875. X    *index(), *rindex(), *getenv();
  876. extern int
  877. X    strcmp(), strncmp(), strlen();
  878. X
  879. extern char
  880. X    *Sprintf(),        /* See comments above function in strings.c */
  881. X    *argv_to_string(),    /* convert a vector of strings into one string */
  882. X    *any(),         /* return first char in str2 that exists in str1 */
  883. X    *basename(),    /* return the last component of a file path */
  884. X    *ctrl_strcpy(),    /* string copy converting control chars to ascii */
  885. X    *itoa(),        /* return a string representation of a number */
  886. X    *lcase_strcpy(),    /* just like strcpy, but convert all chars to lower */
  887. X    *m_xlate(),        /* translate string from ascii to ctrl-char format */
  888. X    *my_atoi(),     /* do an atoi, but return the last char parsed */
  889. X    *no_newln(),    /* remove newline and extra whitespace - return end */
  890. X    *savestr();        /* strcpy arg into malloc-ed memory; return address */
  891. X
  892. extern void
  893. X    print_argv(),    /* prints an argv as one string */
  894. X    putstring();    /* put a string */
  895. SHAR_EOF
  896. chmod 0644 strings.h ||
  897. echo 'restore of strings.h failed'
  898. Wc_c="`wc -c < 'strings.h'`"
  899. test 1396 -eq "$Wc_c" ||
  900.     echo 'strings.h: original size 1396, current size' "$Wc_c"
  901. rm -f _shar_wnt_.tmp
  902. fi
  903. # ============= tool.c ==============
  904. if test -f 'tool.c' -a X"$1" != X"-c"; then
  905.     echo 'x - skipping tool.c (File already exists)'
  906.     rm -f _shar_wnt_.tmp
  907. else
  908. > _shar_wnt_.tmp
  909. echo 'x - extracting tool.c (Text)'
  910. sed 's/^X//' << 'SHAR_EOF' > 'tool.c' &&
  911. /* @(#)tool.c    (c) copyright    10/15/86 (Dan Heller) */
  912. X
  913. /* tool.c --make the mailtool windows, panels, etc... */
  914. #include "mush.h"
  915. X
  916. #ifndef FONTDIR
  917. #define FONTDIR          "/usr/lib/fonts/fixedwidthfonts/"
  918. #endif /* FONTDIR */
  919. X
  920. extern void print_sigwinch(), make_hdr_sw();
  921. extern Notify_value fkey_interposer();
  922. X
  923. static void init_cursors(), geticon();
  924. X
  925. extern Panel /* panels.c */
  926. X    make_hdr_panel(), make_main_panel();
  927. X
  928. Panel
  929. X    main_panel,        /* the main panel dealing with generic items */
  930. X    hdr_panel;        /* panel which contains message header specific items */
  931. X
  932. Textsw mfprint_sw;
  933. Frame compose_frame;
  934. int compose_destroy = 0;
  935. X
  936. static char **choice_args, **button_args;
  937. X
  938. short dat_mail_icon_1[] = {
  939. #include "mail.icon.1"
  940. };
  941. X
  942. short dat_mail_icon_2[] = {
  943. #include "mail.icon.2"
  944. };
  945. X
  946. short dat_compose_icon[] = {
  947. #include "compose.icon"
  948. };
  949. X
  950. short dat_coffee_cup[] = {
  951. X    0x0200,0x0100,0x0600,0x0800,0x0600,0x0100,0xFFF8,0x800C,
  952. X    0x800A,0x4012,0x401C,0x2020,0x9048,0x7FF0,0x3FE0,0x0000
  953. };
  954. X
  955. mpr_static(mail_icon_image1, 64, 64, 1, dat_mail_icon_1);
  956. mpr_static(mail_icon_image2, 64, 64, 1, dat_mail_icon_2);
  957. mpr_static(compose_icon_image, 64, 64, 1, dat_compose_icon);
  958. X
  959. mpr_static(coffee_cup,      16, 16, 1, dat_coffee_cup);
  960. X
  961. /* public for hdr_sw.c */
  962. Cursor l_cursor, m_cursor, r_cursor;
  963. static Cursor coffee;
  964. X
  965. /* text and font will be set in mail_status() */
  966. Icon mail_icon, compose_icon;
  967. X
  968. static Notify_value scroll_hdr();
  969. X
  970. make_tool()
  971. {
  972. X    Rect    mrect;       /* Position and size of icon label. */
  973. X    struct stat rootbuf, tmpbuf;
  974. X    char    *p;
  975. X    struct pixfont *pf_open();
  976. X
  977. X    if (p = do_set(set_options, "font")) {
  978. X    char buf[MAXPATHLEN];
  979. X    (void) sprintf(buf, "%s%s", FONTDIR, p);
  980. X    if (!(mush_font = pf_open(buf)))
  981. X        print("couldn't open font \"%s\"\nUsing default font.\n", buf);
  982. X    }
  983. X    if (!mush_font)
  984. X    mush_font = pf_default();
  985. X
  986. X    geticon();
  987. X    check_icons();
  988. X
  989. X    if (p = do_set(set_options, "screen_win"))
  990. X    screen = atoi(p);
  991. X    else
  992. X    screen = 6;
  993. X
  994. X    /* where to place text on mail icon -- how many messages there are */
  995. X    mrect.r_left = l_width();
  996. X    mrect.r_top = 58-l_height();
  997. X    mrect.r_width = 3*l_width();
  998. X    mrect.r_height = l_height();
  999. X    (void) icon_set(mail_icon, ICON_LABEL_RECT, &mrect, NULL);
  1000. X
  1001. X    (void) window_set(tool,
  1002. X    FRAME_ICON,    mail_icon,
  1003. X    WIN_CONSUME_KBD_EVENTS,
  1004. X        WIN_LEFT_KEYS, WIN_TOP_KEYS, WIN_RIGHT_KEYS, NULL,
  1005. X    NULL);
  1006. X    (void) notify_interpose_destroy_func(tool, destroy_proc);
  1007. X
  1008. X    choice_args = panel_make_list(
  1009. X    PANEL_MENU_TITLE_FONT, mush_font,
  1010. X    PANEL_DISPLAY_LEVEL,    PANEL_NONE,
  1011. X    PANEL_SHOW_MENU,    TRUE,
  1012. X    PANEL_SHOW_MENU_MARK,    FALSE,
  1013. X    NULL);
  1014. X
  1015. X    button_args = panel_make_list(
  1016. X    PANEL_FEEDBACK,        PANEL_INVERTED,
  1017. X    PANEL_SHOW_MENU,    FALSE,
  1018. X    NULL);
  1019. X
  1020. X    hdr_panel = make_hdr_panel(tool, choice_args, button_args);
  1021. X
  1022. X    make_hdr_sw(tool);
  1023. X
  1024. X    main_panel = make_main_panel(tool, choice_args, button_args);
  1025. X
  1026. X    /* main mush frame text subwindow for wprint() */
  1027. X    mfprint_sw = window_create(tool, TEXTSW,
  1028. X    WIN_BELOW,                      main_panel,
  1029. X    WIN_HEIGHT,                     l_height() * 4,
  1030. X    TEXTSW_READ_ONLY,               TRUE,
  1031. X    TEXTSW_BLINK_CARET,             FALSE,
  1032. X    TEXTSW_LINE_BREAK_ACTION,       TEXTSW_WRAP_AT_CHAR,
  1033. X    NULL);
  1034. X    /* order is important -- scroll_textwin should be called first! */
  1035. X    (void) notify_interpose_event_func(mfprint_sw,
  1036. X    fkey_interposer, NOTIFY_SAFE);
  1037. X    (void) notify_interpose_event_func(mfprint_sw,
  1038. X    scroll_textwin, NOTIFY_SAFE);
  1039. X
  1040. X    /* text subwindow for paging messages */
  1041. X    p = do_set(set_options, "crt_win");
  1042. X    pager_textsw = window_create(tool, TEXTSW,
  1043. X    WIN_HEIGHT,            l_height() * (p? atoi(p) : 12),
  1044. X    TEXTSW_READ_ONLY,        TRUE,
  1045. X    TEXTSW_BLINK_CARET,        FALSE,
  1046. #ifdef SUN_4_0 /* SunOS 4.0+ */
  1047. X    TEXTSW_LINE_BREAK_ACTION,    TEXTSW_WRAP_AT_WORD,
  1048. #else /* SUN_4_0 */
  1049. X    TEXTSW_LINE_BREAK_ACTION,    TEXTSW_WRAP_AT_CHAR,
  1050. #endif /* SUN_4_0 */
  1051. X    NULL);
  1052. X    /* order is important -- scroll_textwin should be called first! */
  1053. X    (void) notify_interpose_event_func(pager_textsw,
  1054. X    fkey_interposer, NOTIFY_SAFE);
  1055. X    (void) notify_interpose_event_func(pager_textsw,
  1056. X    scroll_textwin, NOTIFY_SAFE);
  1057. X
  1058. X    (void) sprintf(blank, "%128c", ' ');
  1059. X    mrect = *(Rect *)window_get(hdr_sw, WIN_RECT);
  1060. X    pw_writebackground(hdr_win, 0,0, mrect.r_width, mrect.r_height, PIX_CLR);
  1061. X    istool = 2;
  1062. X    (void) fclose(stdin);
  1063. X    (void) fclose(stdout);
  1064. #ifndef SUN_3_5
  1065. X    /* SunOS 3.5 takes tty modes for ttysws from stderr. */
  1066. X    (void) fclose(stderr);
  1067. #endif /* SUN_3_5 */
  1068. X    (void) do_version();
  1069. X    init_cursors();
  1070. X    timeout_cursors(TRUE);
  1071. X    window_fit_height(tool);
  1072. }
  1073. X
  1074. void
  1075. close_frame()
  1076. {
  1077. X    if (do_set(set_options, "compose_icon")) {
  1078. X    icon_set(compose_icon, ICON_IMAGE, &compose_icon_image, NULL);
  1079. X    window_set(compose_frame, FRAME_CLOSED, TRUE, NULL);
  1080. X    } else
  1081. X    window_set(compose_frame, WIN_SHOW, FALSE, NULL);
  1082. }
  1083. X
  1084. void
  1085. make_compose_frame()
  1086. {
  1087. X    char *p;
  1088. X    Textsw msg_sw;
  1089. X    Panel panel, make_compose_panel();
  1090. X    Notify_value compose_destroy_proc();
  1091. X
  1092. #ifdef SUN_3_5
  1093. X    if (nopenfiles(0) < 8) {
  1094. X    ok_box("Too many frames; close one, please.\n");
  1095. X    compose_frame = 0;
  1096. X    return;
  1097. X    }
  1098. #endif /* SUN_3_5 */
  1099. X
  1100. X    if (do_set(set_options, "compose_icon"))
  1101. X    compose_frame = window_create(NULL, FRAME,
  1102. X        FRAME_LABEL,        "Compose Letter",
  1103. X        FRAME_SHOW_LABEL,    TRUE,
  1104. X        FRAME_NO_CONFIRM,    TRUE,
  1105. X        FRAME_ICON,        compose_icon,
  1106. X        WIN_SHOW,        TRUE,
  1107. X        NULL);
  1108. X    else
  1109. X    compose_frame = window_create(tool, FRAME,
  1110. X        FRAME_LABEL,        "Compose Letter",
  1111. X        FRAME_SHOW_LABEL,    TRUE,
  1112. X        FRAME_NO_CONFIRM,    TRUE,
  1113. X        FRAME_DONE_PROC,    close_frame,
  1114. X        WIN_SHOW,        TRUE,
  1115. X        NULL);
  1116. X    (void) notify_interpose_destroy_func(compose_frame, compose_destroy_proc);
  1117. X
  1118. X    panel = make_compose_panel(compose_frame, choice_args, button_args);
  1119. X
  1120. X    /* text subwindow for composing messages */
  1121. X    p = do_set(set_options, "msg_win");
  1122. X    msg_sw = window_create(compose_frame, TEXTSW,
  1123. X    WIN_BELOW,            panel,
  1124. X    WIN_HEIGHT,            l_height() * (p? atoi(p) : 24),
  1125. X    TEXTSW_READ_ONLY,        TRUE, /* set to false later */
  1126. X    TEXTSW_BLINK_CARET,        FALSE,
  1127. X    TEXTSW_LINE_BREAK_ACTION,    TEXTSW_WRAP_AT_CHAR,
  1128. X    TEXTSW_IGNORE_LIMIT,        TEXTSW_INFINITY,
  1129. X    NULL);
  1130. X    notify_interpose_event_func(msg_sw, fkey_interposer, NOTIFY_SAFE);
  1131. X    notify_interpose_event_func(msg_sw, edit_msg_textwin, NOTIFY_SAFE);
  1132. X
  1133. X    /* Assign textsw (msg_sw) to panel for panel items' callbacks */
  1134. X    panel_set(panel, PANEL_CLIENT_DATA, msg_sw, NULL);
  1135. X
  1136. X    /* tty subwindow */
  1137. X    if (!(tty_sw = window_create(compose_frame, TTY,
  1138. X    TTY_QUIT_ON_CHILD_DEATH, FALSE,
  1139. X    TTY_ARGV,        TTY_ARGV_DO_NOT_FORK,
  1140. X    WIN_CLIENT_DATA,    msg_sw,
  1141. X    WIN_SHOW,        FALSE,
  1142. X    WIN_WIDTH,        WIN_EXTEND_TO_EDGE,
  1143. X    WIN_BELOW,        msg_sw,
  1144. X    NULL)))
  1145. X    perror("tty_sw"), cleanup(0);
  1146. X
  1147. X    /* catch SIGTERM when tty_sw dies */
  1148. X    (void) signal(SIGTERM, catch);
  1149. X    window_fit_height(compose_frame);
  1150. }
  1151. X
  1152. /*ARGSUSED*/
  1153. void
  1154. open_compose()
  1155. {
  1156. X    if (compose_frame) {
  1157. X    if (do_set(set_options, "compose_icon"))
  1158. X        window_set(compose_frame, FRAME_CLOSED, FALSE, NULL);
  1159. X    else
  1160. X        window_set(compose_frame, WIN_SHOW, TRUE, NULL);
  1161. X    } else
  1162. X    make_compose_frame();
  1163. }
  1164. X
  1165. void
  1166. destroy_compose()
  1167. {
  1168. X    if (!compose_destroy && compose_frame)
  1169. X    window_destroy(compose_frame);
  1170. }
  1171. X
  1172. /*ARGSUSED*/
  1173. Notify_value
  1174. compose_destroy_proc(frame, status)
  1175. Frame frame;
  1176. Destroy_status status;
  1177. {
  1178. X    if (!compose_destroy && compose_frame) {
  1179. X    compose_destroy++;
  1180. X    if (ison(glob_flags, IS_GETTING))
  1181. X        rm_edfile(-1);
  1182. X    }
  1183. X    return notify_next_destroy_func(frame, status);
  1184. }
  1185. X
  1186. Panel
  1187. get_compose_panel()
  1188. {
  1189. X    Panel panel;
  1190. X
  1191. #ifdef SUN_4_0
  1192. X    if (do_set(set_options, "compose_icon"))
  1193. X    panel = (Panel)window_get(compose_frame, FRAME_NTH_WINDOW, 0);
  1194. X    else
  1195. X    panel = (Panel)window_get(compose_frame, FRAME_NTH_WINDOW, 1);
  1196. #else
  1197. X    panel = (Panel)window_get(compose_frame, FRAME_NTH_WINDOW, 0);
  1198. #endif /* SUN_4_0 */
  1199. X    return panel;
  1200. }
  1201. X
  1202. void
  1203. close_compose(item, value, event)
  1204. Panel_item item;
  1205. int value;
  1206. Event *event;
  1207. {
  1208. X    if (event_id(event) == MS_LEFT) {
  1209. X    close_frame();
  1210. X    return;
  1211. X    }
  1212. X    switch (value) {
  1213. X    case 0:
  1214. X        close_frame();
  1215. X    when 1:
  1216. X        destroy_compose();
  1217. X    when 2:
  1218. X        (void) help(0, "close", tool_help);
  1219. X    }
  1220. }
  1221. X
  1222. parse_tool_opts(argcp, argv)
  1223. int *argcp;
  1224. char **argv;
  1225. {
  1226. X    if (!(tool = window_create((Window) 0, FRAME,
  1227. X    FRAME_ARGC_PTR_ARGV, argcp, argv,
  1228. X    NULL)))
  1229. X    cleanup(0);
  1230. }
  1231. X
  1232. /*
  1233. X * used by both the hdr_sw (to scroll canvas) and by textsw's.
  1234. X * Return values:
  1235. X *  MUSH_SCROLL_TO (to scroll _to_ a particular location)
  1236. X *  MUSH_SCROLL_RELATIVE (scroll relative our current location)
  1237. X *  MUSH_SCROLL_IGNORE (not a scroll event and ignore it entirely (up events))
  1238. X *  MUSH_SCROLL_PASS_EVENT (not a scroll event; pass it to next event handler)
  1239. X * If absolute scrolling (scroll_to) then "amount" is set to 1 for beginning
  1240. X * of textsw or 2 for end of textsw.
  1241. X * User can precede a keyboard scrolling request by a "count" -- the
  1242. X * count is typed by the user in digits: 5j = move 5 lines down.
  1243. X * It is assumed that if the user moves the mouse after a digit is pressed,
  1244. X * then he doesn't really want to adjust the scrolling amount and the 
  1245. X * count is reset to the default (1).
  1246. X */
  1247. Scroll_action
  1248. decode_scroll(client, event, len, amount)
  1249. Notify_client client;
  1250. Event    *event;
  1251. int len, *amount;
  1252. {
  1253. X    static int count;
  1254. X
  1255. X    if (event_id(event) == LOC_MOVE) {
  1256. X    count = 0;
  1257. X    return MUSH_SCROLL_PASS_EVENT;
  1258. X    }
  1259. X
  1260. X    *amount = 0;  /* Assume relative scroll */
  1261. X    if (ID == SCROLL_REQUEST)
  1262. X    return MUSH_SCROLL_PASS_EVENT;
  1263. X
  1264. X    if (event_is_up(event))
  1265. X    return MUSH_SCROLL_PASS_EVENT;
  1266. X    if (event_is_ascii(event) && isdigit(event_id(event))) {
  1267. X    count = (count * 10) + event_id(event) - '0';
  1268. X    return MUSH_SCROLL_IGNORE;
  1269. X    }
  1270. #ifdef SUN_4_0 /* SunOS 4.0+ */
  1271. X    /* returns sunview events for some ctl chars */
  1272. X    switch (event_action(event)) {
  1273. X    case ACTION_GO_LINE_FORWARD:
  1274. X    case ACTION_GO_COLUMN_FORWARD:
  1275. X        *amount = count ? count : 1;
  1276. X        count = 0;
  1277. X        return MUSH_SCROLL_RELATIVE;
  1278. X    case ACTION_GO_LINE_BACKWARD:
  1279. X    case ACTION_GO_COLUMN_BACKWARD:
  1280. X        *amount = count ? -count : -1;
  1281. X        count = 0;
  1282. X        return MUSH_SCROLL_RELATIVE;
  1283. X    case ACTION_GO_DOCUMENT_START:
  1284. X        *amount = 1;
  1285. X        count = 0;
  1286. X        return MUSH_SCROLL_TO;
  1287. X    case ACTION_GO_DOCUMENT_END:
  1288. X        *amount = 2;
  1289. X        count = 0;
  1290. X        return MUSH_SCROLL_TO;
  1291. X    }
  1292. #endif /* SUN_4_0 */
  1293. X    /* for SunOS 3.5, assume default SunView key mapping */
  1294. X    /* a little redundancy for 4.0, but it's ok */
  1295. X    if (!event_is_ascii(event) && ID != KEY_RIGHT(14) && ID != KEY_RIGHT(8)
  1296. X    && ID != KEY_RIGHT(7) && ID != KEY_RIGHT(13))
  1297. X    /* may have to reset "count" here */
  1298. X    return MUSH_SCROLL_PASS_EVENT; /* Not a scroll event */
  1299. X    switch (event_id(event)) {
  1300. X    case KEY_RIGHT(7):    /* Home on new keyboards */
  1301. X        *amount = 1, count = 0;
  1302. X        return MUSH_SCROLL_TO;
  1303. X    case KEY_RIGHT(13):    /* End on new keyboards */
  1304. X        *amount = 2, count = 0;
  1305. X        return MUSH_SCROLL_TO;
  1306. X    case 'j': case KEY_RIGHT(14):    /* downarrow */
  1307. X        *amount = count ? count : 1;
  1308. X    when 'k': case KEY_RIGHT(8):    /* uparrow */
  1309. X        *amount = count ? -count : -1;
  1310. X    when 'F'-'@':    /* ^f */
  1311. X        *amount = count ? count * (len-1) : len - 1;
  1312. X    when 'D'-'@':    /* ^d */
  1313. X        *amount = len/2;
  1314. X    when 'B'-'@':    /* ^b */
  1315. X        *amount = -(count ? count * (1-len) : len - 1);
  1316. X    when 'U'-'@':    /* ^u */
  1317. X        *amount = -len/2;
  1318. X    when '\033':    /* Escape */
  1319. X        /* For SunOS 3.5 check to see if this is a cursor
  1320. X         * move key, i.e. ESC[A or ESC[B.
  1321. X         */
  1322. X        if (!(int)window_read_event(client, event) &&
  1323. X        event_id(event) == '[' &&
  1324. X        !(int)window_read_event(client, event))
  1325. X            if (event_id(event) == 'A') {
  1326. X            *amount = -1;
  1327. X            break;
  1328. X            } else if (event_id(event) == 'B') {
  1329. X            *amount = 1;
  1330. X            break;
  1331. X            }
  1332. X    default:
  1333. X        count = 0;
  1334. X        return event_is_ascii(event) ?
  1335. X        MUSH_SCROLL_IGNORE : MUSH_SCROLL_PASS_EVENT;
  1336. X    }
  1337. X    count = 0;
  1338. X    /* Scroll indicated amount if event is down, ignore up events */
  1339. X    return MUSH_SCROLL_RELATIVE;
  1340. }
  1341. X
  1342. Notify_value
  1343. scroll_textwin(textsw, event, arg, type)
  1344. Textsw    textsw;
  1345. Event    *event;
  1346. Notify_arg    arg;
  1347. Notify_event_type    type;
  1348. {
  1349. X    int scroll_amount;
  1350. X
  1351. X    switch (decode_scroll(textsw, event, textsw_screen_line_count(textsw),
  1352. X    &scroll_amount)) {
  1353. X    case MUSH_SCROLL_PASS_EVENT :
  1354. X        return notify_next_event_func(textsw, event, arg, type);
  1355. X    case MUSH_SCROLL_IGNORE:
  1356. X        return NOTIFY_IGNORED;
  1357. X    case MUSH_SCROLL_TO:
  1358. X        if (scroll_amount == 1)
  1359. X        window_set(textsw, TEXTSW_FIRST, 0, NULL);
  1360. X        else if (scroll_amount == 2)
  1361. X        window_set(textsw, TEXTSW_FIRST, TEXTSW_INFINITY, NULL);
  1362. X        textsw_scroll_lines(textsw, -textsw_screen_line_count(textsw));
  1363. X        break;
  1364. X    case MUSH_SCROLL_RELATIVE :
  1365. X        textsw_scroll_lines(textsw, scroll_amount);
  1366. X    }
  1367. X    window_set(textsw, TEXTSW_UPDATE_SCROLLBAR, NULL);
  1368. X    return NOTIFY_DONE;
  1369. }
  1370. X
  1371. /*ARGSUSED*/
  1372. Notify_value
  1373. destroy_proc(frame, status)
  1374. Frame frame;
  1375. Destroy_status status;
  1376. {
  1377. X    if (ison(glob_flags, IS_GETTING))
  1378. X    rm_edfile(-1);
  1379. X    /* status is ignored -- maybe post notice asking to confirm quit? */
  1380. X    if (status == DESTROY_CHECKING && ison(glob_flags, DO_UPDATE) &&
  1381. X    !ask("Your folder has been modified.  Quit anyway?"))
  1382. X    (void) notify_veto_destroy(frame);
  1383. X    else
  1384. X    cleanup(0); /* doesn't return */
  1385. X    return NOTIFY_DONE;
  1386. }
  1387. X
  1388. /* Initialise the Mush mail icon. */
  1389. static void
  1390. geticon()
  1391. {
  1392. X    static Rect lrect = { 5, 5, 26, 12 };
  1393. X
  1394. X    mail_icon = icon_create(
  1395. X    ICON_WIDTH,        64,
  1396. X    ICON_HEIGHT,        64,
  1397. X    ICON_FONT,        mush_font,
  1398. X    ICON_IMAGE,        &mail_icon_image1,
  1399. X    ICON_LABEL,        "",
  1400. X    ICON_LABEL_RECT,    &lrect,
  1401. X    0);
  1402. X    compose_icon = icon_create(
  1403. X    ICON_WIDTH,        64,
  1404. X    ICON_HEIGHT,        64,
  1405. X    ICON_IMAGE,        &compose_icon_image,
  1406. X    ICON_LABEL,        "",
  1407. X    0);
  1408. }
  1409. X
  1410. /* Initialise all the cursors used. */
  1411. static void
  1412. init_cursors()
  1413. {
  1414. X    extern Pixrect mouse_left, mouse_middle, mouse_right, bent_arrow;
  1415. X    extern Cursor bentarrow;
  1416. X
  1417. X    l_cursor = cursor_create(
  1418. X    CURSOR_XHOT,    3,
  1419. X    CURSOR_YHOT,    3,
  1420. X    CURSOR_OP,    PIX_SRC,
  1421. X    CURSOR_IMAGE,    &mouse_left,
  1422. X    NULL);
  1423. X    m_cursor = cursor_create(
  1424. X    CURSOR_XHOT,    3,
  1425. X    CURSOR_YHOT,    3,
  1426. X    CURSOR_OP,    PIX_SRC,
  1427. X    CURSOR_IMAGE,    &mouse_middle,
  1428. X    NULL);
  1429. X    r_cursor = cursor_create(
  1430. X    CURSOR_XHOT,    3,
  1431. X    CURSOR_YHOT,    3,
  1432. X    CURSOR_OP,    PIX_SRC,
  1433. X    CURSOR_IMAGE,    &mouse_right,
  1434. X    NULL);
  1435. X    bentarrow = cursor_create(
  1436. X    CURSOR_XHOT,    8,
  1437. X    CURSOR_YHOT,    8,
  1438. X    CURSOR_OP,    PIX_SRC|PIX_DST,
  1439. X    CURSOR_IMAGE,    &bent_arrow,
  1440. X    NULL);
  1441. X    coffee = cursor_create(
  1442. X    CURSOR_XHOT,    8,
  1443. X    CURSOR_YHOT,    8,
  1444. X    CURSOR_OP,    PIX_SRC,
  1445. X    CURSOR_IMAGE,    &coffee_cup,
  1446. X    NULL);
  1447. }
  1448. X
  1449. /* show the timeout cursor (coffee cup) when "on" is TRUE.  This routine
  1450. X * may be called many times in layers of locking mechanisms, so be careful
  1451. X * not to unlock cursors until "on" has been FALSE as many times as it has
  1452. X * been TRUE.
  1453. X */
  1454. void
  1455. timeout_cursors(on)
  1456. int on;
  1457. {
  1458. X    Window win;
  1459. X    Frame subframe;
  1460. X    static int locked, numwins;
  1461. X    int i = 0, j;
  1462. X    static struct {
  1463. X    Cursor cursor;
  1464. X    Window win;
  1465. X    } win_curs[64];
  1466. X
  1467. X    on? locked++ : locked--;
  1468. X    if (istool < 2 || locked > 1 || locked == 1 && on == 0)
  1469. X    return;
  1470. X    if (on) {
  1471. X    for (numwins = 0; win = window_get(tool, FRAME_NTH_SUBWINDOW, numwins);
  1472. X        numwins++) {
  1473. X        win_curs[numwins].cursor =
  1474. X                cursor_copy((Cursor) window_get(win, WIN_CURSOR));
  1475. X        win_curs[numwins].win = win;
  1476. X        window_set(win, WIN_CURSOR, coffee, NULL);
  1477. X    }
  1478. X    while (subframe = window_get(tool, FRAME_NTH_SUBFRAME, i++))
  1479. X        for (j = 0; win = window_get(subframe, FRAME_NTH_SUBWINDOW, j);
  1480. X            j++,numwins++) {
  1481. X        win_curs[numwins].cursor =
  1482. X                cursor_copy((Cursor) window_get(win, WIN_CURSOR));
  1483. X        win_curs[numwins].win = win;
  1484. X        window_set(win, WIN_CURSOR, coffee, NULL);
  1485. X        }
  1486. X    } else {
  1487. X    for (j = 0; j < numwins; j++) {
  1488. X        window_set(win_curs[j].win, WIN_CURSOR, win_curs[j].cursor, NULL);
  1489. X        cursor_destroy(win_curs[j].cursor);
  1490. X    }
  1491. X    }
  1492. }
  1493. X
  1494. /*
  1495. X * If the user has specified an alternate icon or set of icons in
  1496. X * his .mushrc file, copy the image(s) over the defaults.
  1497. X */
  1498. void
  1499. check_icons()
  1500. {
  1501. X    Pixrect *icon_mpr;
  1502. X    char errbuf[256], *icon_file, *icon_path;
  1503. X    int isdir;
  1504. X
  1505. X    if ((icon_file = do_set(set_options, "mail_icon")) && *icon_file) {
  1506. X    isdir = 0;
  1507. X    icon_path = getpath(icon_file, &isdir);
  1508. X    if (isdir == 0) {
  1509. X        if (!(icon_mpr = icon_load_mpr(icon_path, errbuf)))
  1510. X        error("Error loading mail icon file:\n%s",errbuf);
  1511. X        else
  1512. X        pr_rop(&mail_icon_image1, 0,0,64,64, PIX_SRC, icon_mpr, 0, 0);
  1513. X    }
  1514. X    }
  1515. X    if ((icon_file = do_set(set_options, "newmail_icon")) && *icon_file) {
  1516. X    isdir = 0;
  1517. X    icon_path = getpath(icon_file, &isdir);
  1518. X    if (isdir == 0) {
  1519. X        if (!(icon_mpr = icon_load_mpr(icon_path, errbuf)))
  1520. X        error("Error loading newmail icon file:\n%s",errbuf);
  1521. X        else
  1522. X        pr_rop(&mail_icon_image2, 0,0,64,64, PIX_SRC, icon_mpr, 0, 0);
  1523. X    }
  1524. X    }
  1525. X    if ((icon_file = do_set(set_options, "compose_icon")) && *icon_file) {
  1526. X    isdir = 0;
  1527. X    icon_path = getpath(icon_file, &isdir);
  1528. X    if (isdir == 0) {
  1529. X        if (!(icon_mpr = icon_load_mpr(icon_path, errbuf)))
  1530. X        error("Error loading newmail icon file:\n%s",errbuf);
  1531. X        else
  1532. X        pr_rop(&compose_icon_image, 0,0,64,64, PIX_SRC, icon_mpr, 0, 0);
  1533. X    }
  1534. X    }
  1535. }
  1536. SHAR_EOF
  1537. chmod 0644 tool.c ||
  1538. echo 'restore of tool.c failed'
  1539. Wc_c="`wc -c < 'tool.c'`"
  1540. test 16831 -eq "$Wc_c" ||
  1541.     echo 'tool.c: original size 16831, current size' "$Wc_c"
  1542. rm -f _shar_wnt_.tmp
  1543. fi
  1544. # ============= tool_help ==============
  1545. if test -f 'tool_help' -a X"$1" != X"-c"; then
  1546.     echo 'x - skipping tool_help (File already exists)'
  1547.     rm -f _shar_wnt_.tmp
  1548. else
  1549. > _shar_wnt_.tmp
  1550. echo 'x - extracting tool_help (Text)'
  1551. sed 's/^X//' << 'SHAR_EOF' > 'tool_help' &&
  1552. @(#)tool_help    (c) copyright 10/18/86 (Dan Heller)
  1553. X
  1554. %general%
  1555. X
  1556. X      IF ALL ELSE FAILS, READ THE DIRECTIONS!
  1557. X
  1558. This famous  quote applies here more  than ever. If
  1559. you are unfamiliar with Mushview, you should get
  1560. yourself acquainted with it by choosing HELP options
  1561. in menu items. If you get frustrated or confused
  1562. about how to use or run a command, or if you want to
  1563. know how something works or get to know quick shortcuts
  1564. in achieving tasks, it is advisable to look at the
  1565. Help option available with some items.
  1566. %%
  1567. X
  1568. %help%
  1569. Help was designed for users to get help from all commands
  1570. and options.  The last item in many menus is a "help"
  1571. choice.  You will get an appropriate help message describing
  1572. what you can do at the position you are in on the Mushview
  1573. window.
  1574. X
  1575. If a help message isn't much help, it may be more helpful to
  1576. reference a different help item which describes in more detail
  1577. what you want to know.  For example, reading the help for
  1578. "folder" will help you better understand the method in which
  1579. mail messages are stored than it would if you had read the help
  1580. message for "save" first.
  1581. %%
  1582. X
  1583. %mouse%
  1584. The mouse is an image (cursor) which moves across the screen. Its
  1585. position indicates which window is to receive input when you type
  1586. or click a mouse button.
  1587. X
  1588. The mouse may take upon different images which indicate various
  1589. things. When the image looks like a "coffee cup", Mushview is in
  1590. the process of doing something, like sending mail, or reading in
  1591. new mail.  In this event, you should wait till the cursor returns
  1592. to its normal state before attempting to do anything else. Go get
  1593. some coffee.
  1594. X
  1595. When in the Header Window, the cursor will look like the mouse
  1596. device that you hold with the buttons flashing on and off.  This
  1597. is to remind you that you can use each button to do different tasks.
  1598. Using the RIGHT mouse button gives you a menu of options to do for
  1599. the message under the mouse.
  1600. %%
  1601. X
  1602. %respond%
  1603. This item responds to mail in 4 ways.
  1604. In all cases, at least one recipient of your message will be the
  1605. sender of the message you are responding to. If a subject was in
  1606. the author's letter, then it will be used as your subject.
  1607. X
  1608. The first and most used method of response is to the author of the
  1609. message only.  Selecting this item with the LEFT mouse button will
  1610. use this method for responding to mail.
  1611. X
  1612. If you want to include a copy of the author's message, then choose
  1613. the menu item which  says to include the message.  If you wish for
  1614. all the recipients of the message to receive a copy of your reply,
  1615. then choosing the third item will include them.
  1616. X
  1617. The fourth menu item will mail to the author and everyone listed on
  1618. the To and Cc lines of the message, and include the message you are
  1619. responding to in your text.
  1620. X
  1621. In such cases where you include the message you are responding to,
  1622. the included message will be indented by "> " to identify it from
  1623. your message. If you would like to have a string other than the
  1624. default used, then set the appropriate option to whatever you would
  1625. prefer by selecting the "Opts" item, moving the mouse on top of the
  1626. string, "indent-str", selecting the LEFT mouse button and typing the
  1627. desired string.
  1628. %%
  1629. X
  1630. %delete%
  1631. You may  delete or undelete  messages with this item.
  1632. When using the LEFT mouse button, you will delete the
  1633. current message (HIGHLIGHTED in the headers' window).
  1634. Otherwise, you may select the menu item for undelete.
  1635. X
  1636. You may  delete or undelete a  "range" of messages by
  1637. typing the range in the Header Window.
  1638. X
  1639. For help on valid  message ranges, select the menu in
  1640. the area  marked "range" in the  Header Panel Window.
  1641. %%
  1642. X
  1643. %folder%
  1644. Your "folder" is a place to keep all your individual messages. Usually,
  1645. if you are a heavy mail user, you would organize your mail in such a
  1646. way in which related mail would be saved together in one folder.   You
  1647. create folders simply by saving mail to a filename.  Additional mail
  1648. can  be saved to those files in the same way.  To manipulate messages
  1649. in folders,  you "change folders" to the folder you wish to access
  1650. using the folder item.   Since it may occur that you switch  back and
  1651. forth  between two folders, you may use the previous  folder menu item
  1652. which updates changes  made to the current folder and  changes your
  1653. folder to the one previous to  the current.
  1654. X
  1655. You may also select  the exact name of the  folder you wish to access
  1656. by selecting  the left  mouse button on the "folder"  item and TYPING
  1657. the exact  name of the folder  you wish to access.  The "pathname" to
  1658. the folder may start with a tilde (~) indicating your home directory.
  1659. Or, it may  contain a plus sign before the  name indicating your Mail
  1660. directory (+reports, for example).  Alternatively, you  can type  '%'
  1661. to access your system Mailbox, the place where all your mail is first
  1662. delivered.  And finally, you can type '#' to indicate  the previously
  1663. accessed folder.
  1664. %%
  1665. X
  1666. %save%
  1667. You may save messages in  two ways. The most commonly used method is to
  1668. save messages to  your mailbox folder  ("mbox") in your home directory.
  1669. If you use mail very frequently and save large amounts of mail, you can
  1670. save messages to other folders for better organization.
  1671. X
  1672. Usually, when messages are saved, mushtool  marks them for deletion for
  1673. the next update.  If you don't want to have saved messages deleted, you
  1674. must undelete them or set the variable "keepsave" in the options screen.
  1675. X
  1676. There is a text item  in the Main Panel Window which allows you to type
  1677. the  name of the file to save a message.  Type the filename and then
  1678. select the LEFT mouse button over the "Save" item.  If there is no
  1679. filename specified, then messages are saved to your mbox file.
  1680. X
  1681. You may also choose a folder name by selecting the RIGHT mouse button
  1682. over the "Save" item and choosing from the menu of files displayed.
  1683. X
  1684. You can specify a range, or group of messages to save by typing a range
  1685. in the  Header Panel Window.  If there is a  message list in that panel
  1686. item, then the range of messages specified there will be saved. If not,
  1687. the current message will be saved.
  1688. X
  1689. For additional information, see the help option for Folders.
  1690. %%
  1691. X
  1692. %quit%
  1693. There are various ways in which you may be finished with Mushview.
  1694. The most commonly used method  is to simply "close" the tool to an
  1695. iconic form. This means that you haven't really quit, but you have
  1696. merely put it on "hold" till later.  It will become an icon on the
  1697. side or corner of the screen and appear to sit and do nothing.  To
  1698. close the tool to icon form, there are two methods which have will
  1699. have two different effects.
  1700. X
  1701. The first method is to select  this panel item with the left mouse
  1702. button.  This  will update your current  folder (deleting messages
  1703. marked for deletion) and close the tool.  The second method  is to
  1704. use the tool manager around the perimeter of the window and select
  1705. "close".  This will close the tool without updating your mailfile.
  1706. X
  1707. Whenever Mushview is  in the "closed"  state, it  periodically
  1708. checks your mail and updates your folder with the  new mail. While
  1709. Mushview is in iconic form, it will display the number of messages
  1710. you have in the current folder.
  1711. X
  1712. There are two equally similar methods of exiting  Mushview, rather
  1713. than just closing to an icon:  you may select the second menu item
  1714. in the menu given by this panel item or you may use the tool mana-
  1715. ger "quit" item.
  1716. X
  1717. Using the tool manager's quit will exit the tool without updating
  1718. your folder whereas the panel item's menu selection will have the
  1719. Mushview prompt you whether to update the current folder or not.
  1720. %%
  1721. X
  1722. %update%
  1723. This item will update the current folder you are using.  Changes are
  1724. updated to the folder; that is, deleted mail is removed and all other
  1725. mail is copied back to the folder unless otherwise specified. See the
  1726. help in "folder" for more information on folders.
  1727. X
  1728. If new mail has arrived, it will incorporate it. Otherwise, new mail
  1729. is incorporated every two minutes or so, if some comes in.
  1730. %%
  1731. X
  1732. %headers%
  1733. The message headers are displayed in their own separate window.
  1734. The "current" message is usually displayed in either BOLD or
  1735. REVERSE text. This "highlighted" message is the one which is
  1736. displayed at the bottom, larger window. In the message window,
  1737. each message is displayed in the following format:
  1738. the message number is displayed first; if it is the "current"
  1739. message, then there is a '>' sign.
  1740. The next character is the 'status' character:
  1741. X    'N' -- New (and unread)
  1742. X    'U' -- not new, but still Unread
  1743. X    '*' -- delete messages (set show_deleted)
  1744. X    'P' -- preserve in spoolfile.
  1745. X    'O' -- Old message which has also been Read.
  1746. If there is just a space (no character), the message is new, but
  1747. you've already read it. You should explicitly save or delete these.
  1748. X
  1749. Following that is the Author of the message and/or all or part of
  1750. his network address and login name.  Following that is the number
  1751. of lines the message is. In quotes is all or part of the "Subject"
  1752. (if one was specified).
  1753. X
  1754. To read a message, select either the READ item in the main panel
  1755. subwindow or move the mouse over the message header you want to read
  1756. and press the LEFT mouse button. Or, the MIDDLE mouse button will
  1757. delete that message. Choosing the RIGHT mouse button will give you
  1758. SHAR_EOF
  1759. true || echo 'restore of tool_help failed'
  1760. fi
  1761. echo 'End of  part 21'
  1762. echo 'File tool_help is continued in part 22'
  1763. echo 22 > _shar_seq_.tmp
  1764. exit 0
  1765. exit 0 # Just in case...
  1766. -- 
  1767. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1768. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1769. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1770. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1771.