home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Exec 5 / CD_Magazyn_EXEC_nr_5.iso / Programy / Internet / Poczta / YAM22src.lha / YAM_WR.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-11-04  |  96.8 KB  |  2,142 lines
  1. /***************************************************************************
  2.  
  3.  YAM - Yet Another Mailer
  4.  Copyright (C) 2000  Marcel Beck <mbeck@yam.ch>
  5.  
  6.  This program is free software; you can redistribute it and/or modify
  7.  it under the terms of the GNU General Public License as published by
  8.  the Free Software Foundation; either version 2 of the License, or
  9.  (at your option) any later version.
  10.  
  11.  This program is distributed in the hope that it will be useful,
  12.  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  GNU General Public License for more details.
  15.  
  16.  You should have received a copy of the GNU General Public License
  17.  along with this program; if not, write to the Free Software
  18.  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  
  20.  YAM Official Support Site :  http://www.yam.ch
  21.  YAM OpenSource project    :  http://sourceforge.net/projects/yamos/
  22.  
  23. ***************************************************************************/
  24.  
  25. #include "YAM.h"
  26.  
  27. /***************************************************************************
  28.  Module: Write
  29. ***************************************************************************/
  30.  
  31. /*** Translate aliases ***/
  32. /// WR_ResolveName
  33. //  Looks for an alias, email address or name in the address book
  34. char FailedAlias[SIZE_NAME];
  35. int WR_ResolveName(int winnum, char *name, char **adrstr, BOOL nolists)
  36. {
  37.    int hits = 0, i, retcode;
  38.    char *p;
  39.    struct ABEntry *ab;
  40.    struct MUIS_Listtree_TreeNode *tn, *tn2;
  41.    struct Person pe;
  42.  
  43.    ExtractAddress(name, &pe);
  44.    if (pe.Address[0]) if (p = strchr(pe.Address, '@')) // is it an address?
  45.    {
  46.       if (!p[1]) strcpy(p, strchr(C->EmailAddress, '@'));
  47.       if (**adrstr) *adrstr = StrBufCat(*adrstr, ", ");
  48.       *adrstr = StrBufCat(*adrstr, BuildAddrName2(&pe));
  49.       return 0; // no error or warning
  50.    }
  51.    pe.Address[0] = 0;
  52.    stccpy(FailedAlias, name, SIZE_NAME);
  53.    AB_SearchEntry(MUIV_Lt_GetEntry_ListNode_Root, name, ASM_ALIAS|ASM_USER|ASM_LIST|ASM_GROUP, &hits, &tn);
  54.    if (hits > 1) return 3; // multiple matches
  55.    if (!hits)
  56.    {
  57.       AB_SearchEntry(MUIV_Lt_GetEntry_ListNode_Root, name, ASM_REALNAME|ASM_USER|ASM_LIST|ASM_GROUP, &hits, &tn);
  58.       if (hits > 1) return 3; else if (!hits) return 2;
  59.    }
  60.    ab = tn->tn_User;
  61.    switch (ab->Type)
  62.    {
  63.       case AET_USER:
  64.          if (**adrstr) *adrstr = StrBufCat(*adrstr, ", ");
  65.          *adrstr = StrBufCat(*adrstr, BuildAddrName(ab->Address, ab->RealName));
  66.          break;
  67.       case AET_LIST:
  68.          if (nolists) return 4;
  69.          if (winnum >= 0) if ((ab->Address[0] || ab->RealName[0]) && !G->WR[winnum]->ListEntry) G->WR[winnum]->ListEntry = ab;
  70.          if (ab->Members)
  71.          {
  72.             char *ptr;
  73.             for (ptr = ab->Members; *ptr; ptr++)
  74.             {
  75.                char *nptr = strchr(ptr, '\n');
  76.                if (nptr) *nptr = 0; else break;
  77.                retcode = WR_ResolveName(winnum, ptr, adrstr, nolists);
  78.                *nptr = '\n'; ptr = nptr;
  79.                if (retcode) return retcode;
  80.             }
  81.          }
  82.          break;
  83.       case AET_GROUP:
  84.          if (nolists) return 4;
  85.          for (i=0; ; i++)
  86.             if (tn2 = (struct MUIS_Listtree_TreeNode *)DoMethod(G->AB->GUI.LV_ADRESSES, MUIM_Listtree_GetEntry, tn, i, MUIV_Lt_GetEntry_Flags_SameLevel))
  87.             {
  88.                struct ABEntry *ab2 = tn2->tn_User;
  89.                if (retcode = WR_ResolveName(winnum, ab2->Alias, adrstr, nolists)) return retcode;
  90.             }
  91.             else break;
  92.          break;
  93.    }
  94.    return 0;
  95. }
  96. ///
  97. /// WR_ExpandAddresses
  98. //  Expands aliases and names in a recipient field to valid e-mail addresses
  99. char *WR_ExpandAddresses(int winnum, char *src, BOOL quiet, BOOL single)
  100. {
  101.    char *source, *buffer = malloc(strlen(src)+1), *next, *adr = AllocStrBuf(SIZE_DEFAULT);
  102.    int err;
  103.  
  104.    strcpy(source = buffer, src);
  105.    while (source)
  106.    {
  107.       if (!*source) break;
  108.       if (next = MyStrChr(source, ',')) *next++ = 0;
  109.       if (err = WR_ResolveName(winnum, Trim(source), &adr, single))
  110.       {
  111.          if (err == 2 && !quiet) ER_NewError(GetStr(MSG_ER_AliasNotFound), FailedAlias, NULL);
  112.          if (err == 3 && !quiet) ER_NewError(GetStr(MSG_ER_AmbiguousAlias), FailedAlias, NULL);
  113.          if (err == 4 && !quiet) ER_NewError(GetStr(MSG_ER_InvalidAlias), FailedAlias, NULL);
  114.          FreeStrBuf(adr); adr = NULL;
  115.          break;
  116.       }
  117.       if (single) break;
  118.       source = next;
  119.    }
  120.    free(buffer);
  121.    return adr;
  122. }
  123. ///
  124. /// WR_VerifyAutoFunc
  125. //  Checks recipient field (user pressed return key)
  126. SAVEDS ASM void WR_VerifyAutoFunc(REG(a1) int *arg)
  127. {
  128.    APTR str = (APTR)arg[0], next = str;
  129.    char *value, *adr;
  130.    get(str, MUIA_String_Contents, &value);
  131.    if (adr = WR_ExpandAddresses(arg[1], value, TRUE, arg[2]))
  132.    {
  133.       FreeStrBuf(adr);
  134.       get(str, MUIA_UserData, &next);
  135.    }
  136.    else DisplayBeep(0);
  137.    if (next) set(_win(next), MUIA_Window_ActiveObject, next);
  138. }
  139. MakeHook(WR_VerifyAutoHook, WR_VerifyAutoFunc);
  140. ///
  141. /// WR_VerifyManualFunc
  142. //  Checks and expands recipient field (user clicked gadget)
  143. SAVEDS ASM void WR_VerifyManualFunc(REG(a1) int *arg)
  144. {
  145.    APTR object = (APTR)arg[0];
  146.    char *value, *adr;
  147.    get(object, MUIA_String_Contents, &value);
  148.    if (adr = WR_ExpandAddresses(arg[1], value, FALSE, arg[2]))
  149.    {
  150.       setstring(object, adr);
  151.       FreeStrBuf(adr);
  152.    }
  153. }
  154. MakeHook(WR_VerifyManualHook, WR_VerifyManualFunc);
  155. ///
  156.  
  157. /*** Attachments list ***/
  158. /// WR_GetFileEntry
  159. //  Fills form with data from selected list entry
  160. SAVEDS ASM void WR_GetFileEntry(REG(a1) int *arg)
  161. {
  162.    int winnum = *arg;
  163.    struct Attach *attach = NULL;
  164.    struct WR_GUIData *gui = &G->WR[winnum]->GUI;
  165.  
  166.    DoMethod(gui->LV_ATTACH, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &attach);
  167.    DoMethod(G->App, MUIM_MultiSet, MUIA_Disabled, attach ? FALSE : TRUE, gui->RA_ENCODING, gui->ST_CTYPE, gui->ST_DESC, gui->BT_DEL, gui->BT_DISPLAY, NULL);
  168.    if (attach)
  169.    {
  170.       nnset(gui->RA_ENCODING, MUIA_Radio_Active, attach->IsMIME ? 0 : 1);
  171.       nnset(gui->ST_CTYPE, MUIA_String_Contents, attach->ContentType);
  172.       nnset(gui->ST_DESC, MUIA_String_Contents, attach->Description);
  173.    }
  174. }
  175. MakeHook(WR_GetFileEntryHook, WR_GetFileEntry);
  176. ///
  177. /// WR_PutFileEntry
  178. //  Fills form data into selected list entry
  179. SAVEDS ASM void WR_PutFileEntry(REG(a1) int *arg)
  180. {
  181.    int winnum = *arg;
  182.    struct Attach *attach = NULL;
  183.    struct WR_GUIData *gui = &G->WR[winnum]->GUI;
  184.    int ismime;
  185.  
  186.    DoMethod(gui->LV_ATTACH, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &attach);
  187.    if (attach)
  188.    {
  189.       get(gui->RA_ENCODING, MUIA_Radio_Active, &ismime);
  190.       attach->IsMIME = ismime == 0;
  191.       GetMUIString(attach->ContentType, gui->ST_CTYPE);
  192.       GetMUIString(attach->Description, gui->ST_DESC);
  193.       DoMethod(gui->LV_ATTACH, MUIM_List_Redraw, MUIV_List_Redraw_Active);
  194.    }
  195. }
  196. MakeHook(WR_PutFileEntryHook, WR_PutFileEntry);
  197. ///
  198. /// WR_AddFileToList
  199. //  Adds a file to the attachment list, gets its size and type
  200. BOOL WR_AddFileToList(int winnum, char *filename, char *name, BOOL istemp)
  201. {
  202.    static struct Attach attach;
  203.    struct FileInfoBlock *fib;
  204.    struct WR_GUIData *gui = &G->WR[winnum]->GUI;
  205.    char *ctype;
  206.    int encoding;
  207.    BPTR lock;
  208.  
  209.    if (!filename) return FALSE;
  210.    clear(&attach, sizeof(struct Attach));
  211.    if (!(lock = Lock(filename, ACCESS_READ))) return FALSE;
  212.    fib = AllocDosObject(DOS_FIB, NULL);
  213.    Examine(lock, fib);
  214.    attach.Size = fib->fib_Size;
  215.    stccpy(attach.Description, fib->fib_Comment, SIZE_DEFAULT);
  216.    FreeDosObject(DOS_FIB, fib);
  217.    UnLock(lock);
  218.    ctype = IdentifyFile(filename);
  219.    if (*ctype)
  220.    {  
  221.       strcpy(attach.FilePath, filename); 
  222.       strcpy(attach.Name, name ? name : (char *)FilePart(filename));
  223.       get(gui->RA_ENCODING, MUIA_Radio_Active, &encoding);
  224.       attach.IsMIME = encoding == 0;
  225.       attach.IsTemp = istemp;
  226.       strcpy(attach.ContentType, ctype);
  227.       nnset(gui->ST_CTYPE, MUIA_String_Contents, attach.ContentType);
  228.       nnset(gui->ST_DESC, MUIA_String_Contents, attach.Description);
  229.       DoMethod(gui->LV_ATTACH, MUIM_List_InsertSingle, &attach, MUIV_List_Insert_Bottom);
  230.       set(gui->LV_ATTACH, MUIA_List_Active, MUIV_List_Active_Bottom);
  231.       return TRUE;
  232.    }
  233.    return FALSE;
  234. }  
  235. ///
  236.  
  237. /*** Compose Message ***/
  238. /// GetDateTime
  239. //  Formats current date and time for Date header field
  240. char *GetDateTime(void)
  241. {
  242.    static char dt[SIZE_DEFAULT];
  243.    char *tz;
  244.    time_t now;
  245.    struct tm tm;
  246.  
  247.    time(&now);
  248.    tm = *(localtime(&now));
  249.    sprintf(dt, "%s, %02ld %s %ld %02ld:%02ld:%02ld", wdays[tm.tm_wday], tm.tm_mday, months[tm.tm_mon], tm.tm_year+1900, tm.tm_hour, tm.tm_min, tm.tm_sec);
  250.    if (tz = GetTZ()) { strcat(dt, " "); strcat(dt, tz); }
  251.    return dt;  
  252. }
  253. ///
  254. /// NewID
  255. //  Creates a unique id, used for Message-ID header field
  256. char *NewID(BOOL is_msgid) 
  257. {
  258.    static char idbuf[SIZE_MSGID];
  259.    static int ctr = 0;
  260.    struct DateStamp ds;
  261.  
  262.    DateStamp(&ds);
  263.    if (is_msgid) sprintf(idbuf, "yam%ld.%ld.%ld@%s", ds.ds_Days, ds.ds_Tick, FindTask(NULL), C->SMTP_Server);
  264.    else          sprintf(idbuf, "%ld.%ld", FindTask(NULL), ++ctr);
  265.    return idbuf;
  266. }
  267. ///
  268. /// WhichEncodingForFile
  269. //  Determines best MIME encoding mode for a file
  270. int WhichEncodingForFile(char *fname, char *ctype)
  271. {
  272.    int c, linesize=0, total=0, unsafechars=0, binarychars=0, longlines=0;
  273.    FILE *fh = fopen(fname, "r");
  274.  
  275.    if (!fh) return ENC_B64;
  276.    while ((c = fgetc(fh)) != -1)
  277.    {
  278.       if (c > 127) ++unsafechars;
  279.       if (c < 32 && c != '\t' && c != '\n' && c != '\r') ++binarychars;
  280.       ++total;
  281.       if (c == '\n') 
  282.       {
  283.          if (linesize > 79) ++longlines;
  284.          linesize = 0;
  285.       } else ++linesize;
  286.       if (total > 4000 && (longlines || unsafechars || binarychars)) break;
  287.    }
  288.    fclose(fh);
  289.    if (longlines || unsafechars || binarychars)
  290.    {
  291.       if (!strnicmp(ctype, "image/", 6) ||
  292.           !strnicmp(ctype, "audio/", 6) ||
  293.           !strnicmp(ctype, "application/octet-stream", 24) ||
  294.           !strnicmp(ctype, "video/", 6))
  295.          return ENC_B64;
  296.       if (!strnicmp(ctype, "message/", 8)) return (longlines) ? ENC_BIN : ENC_8BIT;
  297.       if (!unsafechars && !binarychars) return C->Allow8bit ? ENC_BIN : ENC_QP;
  298.       if (C->Allow8bit && !binarychars) return ENC_8BIT;
  299.       return (total/++unsafechars < 16) ? ENC_B64 : ENC_QP;
  300.    }
  301.    return ENC_NONE;
  302. }
  303. ///
  304. /// NewPart
  305. //  Initializes a new message part
  306. struct WritePart *NewPart(int winnum)
  307. {
  308.    struct WritePart *p;
  309.    p = (struct WritePart *)calloc(1,sizeof(struct WritePart));
  310.    p->ContentType = "text/plain";
  311.    p->EncType = ENC_NONE;
  312.    p->Filename = G->WR_Filename[winnum];
  313.    p->Name = NULL;
  314.    return p;
  315. }
  316. ///
  317. /// BuildPartsList
  318. //  Builds message parts from attachment list
  319. struct WritePart *BuildPartsList(int winnum)
  320. {
  321.    int i;
  322.    struct Attach *att;
  323.    struct WritePart *first, *p, *np;
  324.  
  325.    first = p = NewPart(winnum); p->IsTemp = TRUE;
  326.    p->EncType = WhichEncodingForFile(p->Filename, p->ContentType);
  327.    for (i = 0; ; i++)
  328.    {
  329.       DoMethod(G->WR[winnum]->GUI.LV_ATTACH, MUIM_List_GetEntry, i, &att);
  330.       if (!att) break;
  331.       p->Next = np = NewPart(winnum); p = np;
  332.       p->ContentType = att->ContentType;
  333.       p->Filename    = att->FilePath;
  334.       p->Description = att->Description;     
  335.       p->Name        = att->Name;
  336.       p->IsTemp      = att->IsTemp;
  337.       if (att->IsMIME) p->EncType = WhichEncodingForFile(p->Filename, p->ContentType);
  338.       else p->EncType = ENC_UUE;
  339.    }
  340.    return first;
  341. }
  342. ///
  343. /// FreePartsList
  344. //  Clears message parts and deletes temporary files
  345. void FreePartsList(struct WritePart *p)
  346. {
  347.    struct WritePart *np;
  348.    for (; p; p = np)
  349.    {
  350.       np = p->Next;
  351.       if (p->IsTemp) DeleteFile(p->Filename);
  352.       free(p);
  353.    }
  354. }
  355. ///
  356. /// WR_CharOut
  357. //  Outputs a single byte of a message header
  358. int WR_CharOut(char c)
  359. {
  360.    if (G->TTout) if (G->TTout->Header) return (int)G->TTout->Table[(UBYTE)c];
  361.    return (int)c;
  362. }
  363. ///
  364. /// firstbad
  365. //  Returns a pointer to the first non-ascii or control character in a string
  366. char *firstbad(char *s)
  367. {
  368.    unsigned char *dum;
  369.    for (dum = (unsigned char *)s; *dum; ++dum)
  370.       if (!isascii(WR_CharOut(*dum)) || iscntrl(WR_CharOut(*dum))) return (char *)dum;
  371.    return NULL;
  372. }
  373. ///
  374. /// PutQP
  375. //  Outputs a base64 encoded, single byte of a message header
  376. void PutQP(unsigned char c, FILE *fh)
  377. {
  378.    static char basis_hex[] = "0123456789ABCDEF";
  379.    fputc('=', fh);
  380.    fputc(basis_hex[c>>4], fh);
  381.    fputc(basis_hex[c&0xF], fh);
  382. }
  383. ///
  384. /// HeaderFputs
  385. //  Outputs the value of a header line (optional QP encoding and charset translation)
  386. void HeaderFputs(char *s, FILE *fh)
  387. {
  388.    char *firstnonascii, *wordstart;
  389.  
  390.    if (!s) return;
  391.    while (firstnonascii = firstbad(s))
  392.    {
  393.       for (wordstart = firstnonascii; wordstart >= s; wordstart--) if (ISpace(*wordstart)) break;
  394.       while (s <= wordstart) { fputc(WR_CharOut(*s), fh); ++s; }
  395.       fprintf(fh, "=?%s?Q?", G->TTout ? G->TTout->DestCharset : C->LocalCharset);
  396.       for (; *s && !ISpace(*s); ++s)
  397.       {
  398.          char c = (char)WR_CharOut(*s);
  399.          if (c > ' ') fputc(c, fh); else PutQP((unsigned char)c, fh);
  400.          }
  401.       fputs("?=", fh);
  402.    }
  403.    while (*s) { fputc(WR_CharOut(*s), fh); ++s; }
  404. }
  405. ///
  406. /// EmitHeader
  407. //  Outputs a complete header line
  408. void EmitHeader(FILE *fh, char *hdr, char *body)
  409. {
  410.    fprintf(fh, "%s: ", hdr);
  411.    HeaderFputs(body, fh);
  412.    fputc('\n', fh);
  413. }
  414. ///
  415. /// EmitRcptField
  416. //  Outputs the value of a recipient header line, one entry per line
  417. void EmitRcptField(FILE *fh, char *body)
  418. {
  419.    char *part, *next, *bodycpy = malloc(strlen(body)+1);
  420.  
  421.    strcpy(part = bodycpy, body);
  422.    while (part)
  423.    {
  424.       if (!*part) break;
  425.       if (next = MyStrChr(part, ',')) *next++ = 0;
  426.       HeaderFputs(Trim(part), fh);
  427.       if (part = next) fputs(",\n\t", fh);
  428.    }
  429.    free(bodycpy);
  430. } 
  431. ///
  432. /// EmitRcptHeader
  433. //  Outputs a complete recipient header line
  434. void EmitRcptHeader(FILE *fh, char *hdr, char *body)
  435. {
  436.    fprintf(fh, "%s: ", hdr);
  437.    EmitRcptField(fh, body ? body : "");
  438.    fputc('\n', fh);
  439. } 
  440. ///
  441. /// FPutsQuoting
  442. //  Handles quotes and slashes
  443. void FPutsQuoting(char *s, FILE *fh)
  444. {
  445.    char *end = s + strlen(s) - 1;
  446.    while (ISpace(*end) && end > s) --end;
  447.    if (*s == '\"') 
  448.    {
  449.       fputc(*s, fh);
  450.       while (*++s) 
  451.       {
  452.          if (*s == '\"') break;
  453.          if (*s == '\\') { fputc(*s, fh); ++s; if (!*s) break; }
  454.          fputc(*s, fh);
  455.       }
  456.       fputc('\"', fh);
  457.    }
  458.    else 
  459.    {
  460.       fputc('\"', fh); fputc(*s, fh);
  461.       while (*++s) 
  462.       {
  463.          if (*s == '\"' || *s == '\\') fputc('\\', fh);
  464.          fputc(*s, fh);
  465.       }
  466.       fputc('\"', fh);
  467.    }
  468. }
  469. ///
  470. /// WriteCtypeNicely
  471. //  Outputs content type
  472. void WriteCtypeNicely(FILE *fh, char *ct)
  473. {
  474.    char *semi, *slash, *eq, *s;
  475.  
  476.    for (s = ct; *s; ++s) if (*s == '\n') *s = ' ';
  477.    if (semi = (char *)index(ct, ';')) *semi = '\0';
  478.    slash = (char *)index(ct, '/');
  479.    fputs(ct, fh);
  480.    if (!slash) fputs("/unknown", fh);
  481.    while (semi) 
  482.    {
  483.       ct = semi + 1;
  484.       *semi = ';';
  485.       if (semi = (char *) index(ct, ';')) *semi = '\0';
  486.       if (eq = (char *) index(ct, '=')) *eq = '\0';
  487.       fputs(";\n\t", fh);
  488.       while (ISpace(*ct)) ++ct;
  489.       fputs(ct, fh);
  490.       if (eq) 
  491.       {
  492.          s = eq;
  493.          fputc('=', fh);
  494.          ++s;
  495.          while (ISpace(*s)) ++s;
  496.          FPutsQuoting(s, fh);
  497.          *eq = '=';
  498.       }
  499.    }
  500. }
  501. ///
  502. /// WriteContentTypeAndEncoding
  503. //  Outputs content type header including parameters
  504. void WriteContentTypeAndEncoding(FILE *fh, struct WritePart *part)
  505. {
  506.    char *p;
  507.    fputs("Content-Type: ", fh);
  508.    WriteCtypeNicely(fh, part->ContentType);
  509.    if (!strncmp(part->ContentType, "text/", 5) && (part->EncType != ENC_NONE || part->TTable))
  510.       fprintf(fh, "; charset=%s", part->TTable ? part->TTable->DestCharset : C->LocalCharset);
  511.    if (p = part->Name) if (*p) 
  512.    {
  513.       fputs("; name=\"", fh);
  514.       HeaderFputs(p, fh);
  515.       fputs("\"\nContent-Disposition: attachment; filename=\"", fh);
  516.       HeaderFputs(p, fh);
  517.       fputc('\"', fh);
  518.    }
  519.    fputc('\n', fh);
  520.    if (part->EncType != ENC_NONE)
  521.    {
  522.       fputs("Content-Transfer-Encoding: ", fh);
  523.       switch (part->EncType)
  524.       {
  525.          case ENC_B64:  fputs("base64\n", fh); break;
  526.          case ENC_QP:   fputs("quoted-printable\n", fh); break;
  527.          case ENC_UUE:  fputs("x-uue\n", fh); break;
  528.          case ENC_8BIT: fputs("8bit\n", fh); break;
  529.          case ENC_BIN:  fputs("binary\n", fh); break;
  530.       }
  531.    }
  532.    if (p = part->Description) if (*p) EmitHeader(fh, "Content-Description", p);
  533. }
  534. ///
  535. /// WR_WriteUIItem
  536. //  Outputs a single parameter of the X-SenderInfo header
  537. void WR_WriteUIItem(FILE *fh, int *len, char *parameter, char *value)
  538. {
  539.    int l = 6+strlen(parameter)+strlen(value);
  540.    *len += l;
  541.    fputc(';', fh); if (*len > 80) { fputs("\n  ", fh); *len = l; }
  542.    fprintf(fh, " %s=\"", parameter);
  543.    HeaderFputs(value, fh);
  544.    fputc('\"', fh);
  545. }
  546. ///
  547. /// WR_WriteUserInfo
  548. //  Outputs X-SenderInfo header line
  549. void WR_WriteUserInfo(FILE *fh)
  550. {
  551.    int len = 15, hits = 0;
  552.    struct ABEntry *ab = NULL;
  553.    struct MUIS_Listtree_TreeNode *tn;
  554.  
  555.    if (AB_SearchEntry(MUIV_Lt_GetEntry_ListNode_Root, C->EmailAddress, ASM_ADDRESS|ASM_USER, &hits, &tn))
  556.    {
  557.       ab = tn->tn_User;
  558.       if (ab->Type != AET_USER) ab = NULL;
  559.       else if (!*ab->Homepage && !*ab->Phone && !*ab->Street && !*ab->City && !*ab->Country && !ab->BirthDay) ab = NULL;
  560.    }
  561.    if (!ab && !*C->MyPictureURL) return;
  562.    fputs("X-SenderInfo: 1", fh);
  563.    if (*C->MyPictureURL) WR_WriteUIItem(fh, &len, "picture", C->MyPictureURL);
  564.    if (ab)
  565.    {
  566.       if (*ab->Homepage) WR_WriteUIItem(fh, &len, "homepage", ab->Homepage);
  567.       if (*ab->Street)   WR_WriteUIItem(fh, &len, "street", ab->Street);
  568.       if (*ab->City)     WR_WriteUIItem(fh, &len, "city", ab->City);
  569.       if (*ab->Country)  WR_WriteUIItem(fh, &len, "country", ab->Country);
  570.       if (*ab->Phone)    WR_WriteUIItem(fh, &len, "phone", ab->Phone);
  571.       if (ab->BirthDay)  fprintf(fh, "; dob=%ld", ab->BirthDay);
  572.    }
  573.    fputc('\n', fh);
  574. }
  575. ///
  576. /// EncodePart
  577. //  Encodes a message part
  578. void EncodePart(FILE *ofh, struct WritePart *part)
  579. {
  580.    FILE *ifh;
  581.  
  582.    if (ifh = fopen(part->Filename, "r"))
  583.    {
  584.       int size;
  585.       switch (part->EncType) 
  586.       {
  587.          case ENC_B64: to64(ifh, ofh, DoesNeedPortableNewlines(part->ContentType));
  588.                        break;
  589.          case ENC_QP:  toqp(ifh, ofh);
  590.                        break;
  591.          case ENC_UUE: size = FileSize(part->Filename);
  592.                        fprintf(ofh, "begin 644 %s\n", *part->Name ? part->Name : (char *)FilePart(part->Filename));
  593.                        touue(ifh, ofh);
  594.                        fprintf(ofh, "end\nsize %ld\n", size);
  595.                        break;
  596.          default:      CopyFile(NULL, ofh, NULL, ifh);
  597.       }
  598.       fclose(ifh);
  599.    }
  600. }
  601. ///
  602. /// WR_CreateHashTable
  603. //  Creates an index table for a database file
  604. BOOL WR_CreateHashTable(char *source, char *hashfile, char *sep)
  605. {
  606.    char buffer[SIZE_LARGE];
  607.    long fpos, l = strlen(sep);
  608.    FILE *in, *out;
  609.    BOOL success = FALSE;
  610.  
  611.    if (in = fopen(source, "r"))
  612.    {
  613.       if (out = fopen(hashfile, "w"))
  614.       {
  615.          fpos = 0; fwrite(&fpos, sizeof(long), 1, out);
  616.          while (fgets(buffer, SIZE_LARGE, in))
  617.             if (!strncmp(buffer, sep, l)) { fpos = ftell(in); fwrite(&fpos, sizeof(long), 1, out); }
  618.          success = TRUE;
  619.          fclose(out);
  620.       }
  621.       fclose(in);
  622.    }
  623.    return success;
  624. }
  625. ///
  626. /// WR_AddTagline
  627. //  Randomly selects a tagline and writes it to the message file
  628. void WR_AddTagline(FILE *fh_mail)
  629. {
  630.    FILE *fh_tag, *fh_hash;
  631.    char buf[SIZE_LARGE], hashfile[SIZE_PATHFILE];
  632.    long fpos, hsize;
  633.  
  634.    if (*C->TagsFile) 
  635.    {
  636.       sprintf(hashfile, "%s.hsh", C->TagsFile);
  637.       if (getft(C->TagsFile) > getft(hashfile)) WR_CreateHashTable(C->TagsFile, hashfile, C->TagsSeparator);
  638.       if (fh_tag = fopen(C->TagsFile, "r"))
  639.       {
  640.          if (fh_hash = fopen(hashfile, "r"))
  641.          {
  642.             fseek(fh_hash, 0, SEEK_END); hsize = ftell(fh_hash);
  643.             if ((hsize = hsize/sizeof(long)) > 1)
  644.             {
  645.                fpos = (((long)rand())%hsize)*sizeof(long);
  646.                fseek(fh_hash, fpos, SEEK_SET); fread(&fpos, sizeof(long), 1, fh_hash);
  647.                fseek(fh_tag, fpos, SEEK_SET);
  648.                if (GetLine(fh_tag, buf, SIZE_LARGE)) fprintf(fh_mail, buf);
  649.                while (GetLine(fh_tag, buf, SIZE_LARGE))
  650.                   if (!strncmp(buf, C->TagsSeparator, strlen(C->TagsSeparator))) break;
  651.                   else fprintf(fh_mail, "\n%s", buf);
  652.             }
  653.             fclose(fh_tag);
  654.          }
  655.          else ER_NewError(GetStr(MSG_ER_CantOpenFile), hashfile, NULL);
  656.       }
  657.       else ER_NewError(GetStr(MSG_ER_CantOpenFile), C->TagsFile, NULL);
  658.    }
  659. }
  660. ///
  661. /// WR_WriteSignature
  662. //  Writes signature to the message file
  663. void WR_WriteSignature(FILE *out, int signat)
  664. {
  665.    FILE *in;
  666.    int ch;
  667.    if (in = fopen(CreateFilename(SigNames[signat]), "r"))
  668.    {
  669.       fputs("-- \n", out);
  670.       while ((ch = fgetc(in)) != EOF)
  671.       {
  672.          if (ch == '%')
  673.          {
  674.             ch = fgetc(in);
  675.             if (ch == 't') { WR_AddTagline(out); continue; }
  676.             if (ch == 'e') { CopyFile(NULL, out, "ENV:SIGNATURE", NULL); continue; }
  677.             ungetc(ch, in); ch = '%';
  678.          }
  679.          fputc(ch, out);
  680.       }
  681.       fclose(in);
  682.    }
  683. }
  684. ///
  685. /// WR_AddSignature
  686. //  Adds a signature to the end of the file
  687. void WR_AddSignature(char *mailfile, int signat)
  688. {
  689.    FILE *fh_mail;
  690.    BOOL addline = FALSE;
  691.  
  692.    if (signat == -1) 
  693.    {
  694.       signat = C->UseSignature ? 1 : 0;
  695.       if (fh_mail = fopen(mailfile, "r"))
  696.       {
  697.          fseek(fh_mail, -1, SEEK_END);
  698.          addline = fgetc(fh_mail) != '\n';
  699.          fclose(fh_mail);
  700.       }
  701.    }
  702.    if (fh_mail = fopen(mailfile, "a"))
  703.    {
  704.       if (addline) fputc('\n', fh_mail);
  705.       if (signat) WR_WriteSignature(fh_mail, signat-1);
  706.       fclose(fh_mail);
  707.    }
  708. }
  709. ///
  710. /// WR_Anonymize
  711. //  Inserts recipient header field for remailer service
  712. void WR_Anonymize(FILE *fh, char *body)
  713. {
  714.    char *ptr;
  715.  
  716.    for (ptr = C->RMCommands; *ptr; ptr++)
  717.    {
  718.       if (*ptr == '\\') if (*(ptr+1) == 'n') { ptr++; fputs("\n", fh); continue; }
  719.       if (*ptr == '%') if (*(ptr+1) == 's') { ptr++; EmitRcptField(fh, body); continue; }
  720.       fputc(*ptr, fh);
  721.    }
  722.    fputs("\n", fh);
  723. }
  724. ///
  725. /// WR_GetPGPId
  726. //  Gets PGP key id for a person
  727. char *WR_GetPGPId(struct Person *pe)
  728. {
  729.    int hits;
  730.    char *pgpid = NULL;
  731.    struct MUIS_Listtree_TreeNode *tn;
  732.    if (!AB_SearchEntry(MUIV_Lt_GetEntry_ListNode_Root, pe->RealName, ASM_REALNAME|ASM_USER, &hits, &tn))
  733.         AB_SearchEntry(MUIV_Lt_GetEntry_ListNode_Root, pe->Address, ASM_ADDRESS|ASM_USER, &hits, &tn);
  734.    if (hits) if (((struct ABEntry *)(tn->tn_User))->PGPId[0]) pgpid = ((struct ABEntry *)(tn->tn_User))->PGPId;
  735.    return pgpid;
  736. }
  737. ///
  738. /// WR_GetPGPIds
  739. //  Collects PGP key ids for all persons in a recipient field
  740. char *WR_GetPGPIds(char *source, char *ids)
  741. {
  742.    struct Person pe;
  743.    char *next, *pid;
  744.  
  745.    for (; source; source = next)
  746.    {
  747.       if (!*source) break;
  748.       if (next = MyStrChr(source, ',')) *next++ = 0;
  749.       ExtractAddress(source, &pe);
  750.       if (!(pid = WR_GetPGPId(&pe)))
  751.       {
  752.          pid = pe.RealName[0] ? pe.RealName : pe.Address;
  753.          ER_NewError(GetStr(MSG_ER_ErrorNoPGPId), source, pid);
  754.       }
  755.       ids = StrBufCat(ids, (G->PGPVersion == 5) ? "-r \"" : "\"");
  756.       ids = StrBufCat(ids, pid);
  757.       ids = StrBufCat(ids, "\" ");
  758.    }
  759.    return ids;
  760. }
  761. ///
  762.  
  763. /// WR_Bounce
  764. //  Bounce message: inserts resent-headers while copying the message
  765. BOOL WR_Bounce(FILE *fh, struct Compose *comp)
  766. {
  767.    FILE *oldfh;
  768.    if (oldfh = fopen(GetMailFile(NULL, NULL, comp->OrigMail), "r"))
  769.    {
  770.       BOOL infield = FALSE, inbody = FALSE;
  771.       char buf[SIZE_LINE];
  772.       while (fgets(buf, SIZE_LINE, oldfh))
  773.       {
  774.          if (*buf == '\n' && !inbody)
  775.          {
  776.             inbody = TRUE;
  777.             EmitRcptHeader(fh, "To", comp->MailTo);
  778.             EmitHeader(fh, "Resent-From", BuildAddrName(C->EmailAddress, C->RealName));
  779.             EmitHeader(fh, "Resent-Date", GetDateTime());
  780.          }
  781.          if (!ISpace(*buf) && !inbody) infield = !strnicmp(buf, "to:", 3);
  782.          if (!infield || inbody) fputs(buf, fh);
  783.       }
  784.       fclose(oldfh);
  785.       return TRUE;
  786.    }
  787.    return FALSE;
  788. }
  789. ///
  790. /// WR_SaveDec
  791. //  Creates decrypted copy of a PGP encrypted message
  792. BOOL WR_SaveDec(FILE *fh, struct Compose *comp)
  793. {
  794.    FILE *oldfh;
  795.    if (oldfh = fopen(GetMailFile(NULL, NULL, comp->OrigMail), "r"))
  796.    {
  797.       BOOL infield = FALSE;
  798.       char buf[SIZE_LINE];
  799.       while (fgets(buf, SIZE_LINE, oldfh))
  800.       {
  801.          if (*buf == '\n') { fprintf(fh, "X-YAM-Decrypted: PGP; %s\n", GetDateTime()); break; }
  802.          if (!ISpace(*buf)) infield = !strnicmp(buf, "content-type:", 13)
  803.                                    || !strnicmp(buf, "content-transfer-encoding", 25)
  804.                                    || !strnicmp(buf, "mime-version:", 13);
  805.          if (!infield) fputs(buf, fh);
  806.       }
  807.       fclose(oldfh);
  808.       return TRUE;
  809.    }
  810.    return FALSE;
  811. }
  812. ///
  813. /// WR_EmitExtHeader
  814. //  Outputs special X-YAM-Header lines to remember user-defined headers
  815. void WR_EmitExtHeader(FILE *fh, struct Compose *comp)
  816. {
  817.    if (*comp->ExtHeader)
  818.    {
  819.       char *p, ch = '\n';
  820.       for (p = comp->ExtHeader; *p; ++p)
  821.       {
  822.          if (ch == '\n') fputs("X-YAM-Header-", fh);
  823.          if (*p != '\\') ch = *p;
  824.          else if (*++p == '\\') ch = '\\'; else if (*p == 'n') ch = '\n';
  825.          fputc(ch, fh);
  826.       }
  827.       if (ch != '\n') fputc('\n', fh);
  828.    }
  829. }
  830. ///
  831. /// WR_ComposeReport
  832. //  Assembles the parts of a message disposition notification
  833. const char *MIMEwarn = "Warning: This is a message in MIME format. Your mail reader does not\n"
  834.                        "support MIME. Some parts of this message will be readable as plain text.\n"
  835.                        "To see the rest, you will need to upgrade your mail reader. Following are\n"
  836.                        "some URLs where you can find MIME-capable mail programs for common platforms:\n\n"
  837.                        "  Amiga............: YAM          http://www.yam.ch/\n"
  838.                        "  Unix.............: Metamail     ftp://ftp.bellcore.com/nsb/\n"
  839.                        "  Windows/Macintosh: Eudora       http://www.qualcomm.com/\n\n"
  840.                        "General info about MIME can be found at:\n\n"
  841.                        "http://www.cis.ohio-state.edu/hypertext/faq/usenet/mail/mime-faq/top.html\n\n";
  842. const char *PGPwarn  = "The following body part contains a PGP encrypted message. Either your\n"
  843.                        "mail reader doesn't support MIME/PGP as specified in RFC 2015, or\n"
  844.                        "the message was encrypted for someone else. To read the encrypted\n"
  845.                        "message, run the next body part through Pretty Good Privacy.\n\n";
  846. void WR_ComposeReport(FILE *fh, struct Compose *comp, char *boundary)
  847. {
  848.    struct WritePart *p;
  849.    fprintf(fh, "Content-type: multipart/report; report-type=disposition-notification; boundary=\"%s\"\n\n", boundary);
  850.    for (p = comp->FirstPart; p; p = p->Next)
  851.    {
  852.       fprintf(fh, "\n--%s\n", boundary);
  853.       WriteContentTypeAndEncoding(fh, p);
  854.       fputs("\n", fh);
  855.       EncodePart(fh, p);
  856.    }
  857.    fprintf(fh, "\n--%s--\n\n", boundary);
  858. }
  859. ///
  860. /// WR_ComposePGP
  861. //  Creates a signed and/or encrypted PGP/MIME message
  862. BOOL WR_ComposePGP(FILE *fh, struct Compose *comp, char *boundary)
  863.  {
  864.    int sec = comp->Security;
  865.    BOOL success = FALSE;
  866.    struct WritePart pgppart, *firstpart = comp->FirstPart;
  867.    char *ids = AllocStrBuf(SIZE_DEFAULT), pgpfile[SIZE_PATHFILE], options[SIZE_LARGE];
  868.    struct TempFile *tf, *tf2 = NULL;
  869.  
  870.    pgppart.Filename = pgpfile; *pgpfile = 0;
  871.    pgppart.EncType = ENC_NONE;
  872.    if (sec & 2)
  873.    {
  874.       if (comp->MailTo) ids = WR_GetPGPIds(comp->MailTo, ids);
  875.       if (comp->MailCC) ids = WR_GetPGPIds(comp->MailCC, ids);
  876.       if (comp->MailBCC) ids = WR_GetPGPIds(comp->MailBCC, ids);
  877.       if (C->EncryptToSelf && *C->MyPGPID)
  878.       {
  879.          if (G->PGPVersion == 5) ids = StrBufCat(ids, "-r ");
  880.          ids = StrBufCat(ids, C->MyPGPID);
  881.       }
  882.    }
  883.    tf2 = OpenTempFile(NULL);
  884.    if (tf = OpenTempFile("w"))
  885.    {
  886.       WriteContentTypeAndEncoding(tf->FP, firstpart);
  887.       fputc('\n', tf->FP);
  888.       EncodePart(tf->FP, firstpart);
  889.       fclose(tf->FP); tf->FP = NULL;
  890.       ConvertCRLF(tf->Filename, tf2->Filename, TRUE);
  891.       CloseTempFile(tf);
  892.       sprintf(pgpfile, "%s.asc", tf2->Filename);
  893.       if (sec & 1) PGPGetPassPhrase();
  894.       switch (sec)
  895.       {
  896.          case 1: /* sign */
  897.             fprintf(fh, "Content-type: multipart/signed; boundary=\"%s\"; micalc=pgp-md5; protocol=\"application/pgp-signature\"\n\n%s\n--%s\n", boundary, MIMEwarn, boundary);
  898.             WriteContentTypeAndEncoding(fh, firstpart);
  899.             fputc('\n', fh);
  900.             EncodePart(fh, firstpart);
  901.             fprintf(fh, "\n--%s\nContent-Type: application/pgp-signature\n\n", boundary);
  902.             sprintf(options, (G->PGPVersion == 5) ? "-ab %s +batchmode=1 +force" : "-sab %s +bat +f", tf2->Filename);
  903.             if (*C->MyPGPID) { strcat(options, " -u "); strcat(options, C->MyPGPID); }
  904.             if (!PGPCommand((G->PGPVersion == 5) ? "pgps" : "pgp", options, 0)) success = TRUE;
  905.             break;
  906.          case 2: /* encrypt */
  907.             fprintf(fh, "Content-type: multipart/encrypted; boundary=\"%s\"; protocol=\"application/pgp-encrypted\"\n\n%s\n--%s\n", boundary, MIMEwarn, boundary);
  908.             fprintf(fh, "Content-Type: application/pgp-encrypted\n\nVersion: 1\n\n%s\n--%s\nContent-Type: application/octet-stream\n\n", PGPwarn, boundary);
  909.             sprintf(options, (G->PGPVersion == 5) ? "-a %s %s +batchmode=1 +force" : "-ea %s %s +bat +f", tf2->Filename, ids);
  910.             if (!PGPCommand((G->PGPVersion == 5) ? "pgpe" : "pgp", options, 0)) success = TRUE;
  911.             break;
  912.          case 3: /* sign+encrypt */
  913.             fprintf(fh, "Content-type: multipart/encrypted; boundary=\"%s\"; protocol=\"application/pgp-encrypted\"\n\n%s\n--%s\n", boundary, MIMEwarn, boundary);
  914.             fprintf(fh, "Content-Type: application/pgp-encrypted\n\nVersion: 1\n\n%s\n--%s\nContent-Type: application/octet-stream\n\n", PGPwarn, boundary);
  915.             sprintf(options, (G->PGPVersion == 5) ? "-a %s %s +batchmode=1 +force -s" : "-sea %s %s +bat +f", tf2->Filename, ids);
  916.             if (*C->MyPGPID) { strcat(options, " -u "); strcat(options, C->MyPGPID); }
  917.             if (!PGPCommand((G->PGPVersion == 5) ? "pgpe" : "pgp", options, 0)) success = TRUE;
  918.             break;
  919.       }
  920.       if (success) EncodePart(fh, &pgppart);
  921.    }
  922.    CloseTempFile(tf2);
  923.    if (*pgpfile) remove(pgpfile);
  924.    fprintf(fh, "\n--%s--\n\n", boundary);
  925.    FreeStrBuf(ids);
  926.    PGPClearPassPhrase(!success);
  927.    return success;
  928. }
  929. ///
  930. /// WR_ComposeMulti
  931. //  Assembles a multipart message
  932. void WR_ComposeMulti(FILE *fh, struct Compose *comp, char *boundary)
  933. {
  934.    struct WritePart *p;
  935.    fprintf(fh, "Content-type: multipart/mixed; boundary=\"%s\"\n\n", boundary);
  936.    fputs(MIMEwarn, fh);
  937.    for (p = comp->FirstPart; p; p = p->Next)
  938.    {
  939.       fprintf(fh, "\n--%s\n", boundary);
  940.       WriteContentTypeAndEncoding(fh, p);
  941.       if (comp->Security == 4) WR_Anonymize(fh, comp->MailTo);
  942.       fputs("\n", fh);
  943.       EncodePart(fh, p);
  944.    }
  945.    fprintf(fh, "\n--%s--\n\n", boundary);
  946. }
  947. ///
  948. /// WriteOutMessage
  949. //  Outputs header and body of a new message
  950. BOOL WriteOutMessage(struct Compose *comp)
  951. {
  952.    FILE *fh = comp->FH;
  953.    struct WritePart *firstpart = comp->FirstPart;
  954.    char boundary[SIZE_DEFAULT], options[SIZE_DEFAULT], *rcptto;
  955.    
  956.    if (comp->Mode == NEW_BOUNCE)
  957.    {
  958.       if (comp->DelSend) EmitHeader(fh, "X-YAM-Options", "delsent");
  959.       return WR_Bounce(fh, comp);
  960.    }
  961.    if (comp->Mode == NEW_SAVEDEC) if (!WR_SaveDec(fh, comp)) return FALSE; else goto mimebody;
  962.    if (!firstpart) return FALSE;
  963.    if (firstpart->Next && comp->Security >= 1 && comp->Security <= 3)
  964.    {
  965.       ER_NewError(GetStr(MSG_WR_PGPMIMEconflict), NULL, NULL);
  966.       comp->Security = 0;
  967.    }
  968.    *options = 0;
  969.    if (comp->DelSend) strcat(options, ",delsent");
  970.    if (comp->Security) sprintf(&options[strlen(options)], ",%s", SecCodes[comp->Security]);
  971.    if (comp->Signature) sprintf(&options[strlen(options)], ",sigfile%ld", comp->Signature-1);
  972.    if (*options) EmitHeader(fh, "X-YAM-Options", &options[1]);
  973.    EmitHeader(fh, "From", comp->From ? comp->From : BuildAddrName(C->EmailAddress, C->RealName));
  974.    if (comp->ReplyTo) EmitHeader(fh, "Reply-To", comp->ReplyTo);
  975.    if (comp->MailTo) EmitRcptHeader(fh, "To", comp->Security == 4 ? C->ReMailer : comp->MailTo);
  976.    if (comp->MailCC) EmitRcptHeader(fh, "CC", comp->MailCC);
  977.    if (comp->MailBCC) EmitRcptHeader(fh, "BCC", comp->MailBCC);
  978.    EmitHeader(fh, "Date", GetDateTime());
  979.    fprintf(fh, "Message-ID: <%s>\n", NewID(True));
  980.    if (comp->IRTMsgID) EmitHeader(fh, "In-Reply-To", comp->IRTMsgID);
  981.    rcptto = comp->ReplyTo ? comp->ReplyTo : (comp->From ? comp->From : C->EmailAddress);
  982.    if (comp->Receipt & 1) EmitHeader(fh, "Return-Receipt-To", rcptto);
  983.    if (comp->Receipt & 2) EmitHeader(fh, "Disposition-Notification-To", rcptto);
  984.    if (comp->Importance) EmitHeader(fh, "Importance", comp->Importance == 1 ? "High" : "Low");
  985.    fprintf(fh, "X-Mailer: YAM %s AmigaOS E-Mail Client (c) 1995-2000 by Marcel Beck  http://www.yam.ch\n", __VERSION__);
  986.    if (comp->UserInfo) WR_WriteUserInfo(fh);
  987.    if (*C->Organization) EmitHeader(fh, "Organization", C->Organization);
  988.    if (*comp->Subject) EmitHeader(fh, "Subject", comp->Subject);
  989.    if (comp->ExtHeader) WR_EmitExtHeader(fh, comp);
  990. mimebody:
  991.    fputs("MIME-Version: 1.0\n", fh);
  992.    sprintf(boundary, "BOUNDARY.%s", NewID(False));
  993.    if (comp->ReportType > 0) WR_ComposeReport(fh, comp, boundary);
  994.    else if (comp->Security >= 1 && comp->Security <= 3) return WR_ComposePGP(fh, comp, boundary);
  995.    else if (firstpart->Next) WR_ComposeMulti(fh, comp, boundary);
  996.    else
  997.    {
  998.       WriteContentTypeAndEncoding(fh, firstpart);
  999.       if (comp->Security == 4 && comp->OldSecurity != 4) WR_Anonymize(fh, comp->MailTo);
  1000.       fputs("\n", fh);
  1001.       EncodePart(fh, firstpart);
  1002.    }
  1003.    return TRUE;
  1004. }
  1005. ///
  1006. /// WR_AutoSaveFile
  1007. //  Returns filename of the auto-save file
  1008. char *WR_AutoSaveFile(int winnr)
  1009. {
  1010.    static char fname[SIZE_PATHFILE];
  1011.    strmfp(fname, G->ProgDir, ".autosave");
  1012.    strcat(fname, itoa(winnr));
  1013.    strcat(fname, ".txt");
  1014.    return fname;
  1015. }
  1016. ///
  1017.  
  1018. /*** Buttons ***/
  1019. /// WR_NewMail
  1020. //  Validates write window options and generates a new message
  1021. void WR_NewMail(int mode, int winnum)
  1022. {
  1023.    struct Compose comp;
  1024.    char *addr, *er;
  1025.    static struct Mail mail;
  1026.    struct Mail *new = NULL, *mlist[3];
  1027.    int i, att = 0;
  1028.    struct WR_ClassData *wr = G->WR[winnum];
  1029.    struct WR_GUIData *gui = &wr->GUI;
  1030.    struct Folder *outfolder = FO_GetFolderByType(FT_OUTGOING, NULL);
  1031.  
  1032.    set(gui->RG_PAGE, MUIA_Group_ActivePage, 0);
  1033.    clear(&mail, sizeof(struct Mail));
  1034.    clear(&comp, sizeof(struct Compose));
  1035.    mlist[0] = (struct Mail *)1; mlist[1] = NULL;
  1036.    get(gui->ST_TO, MUIA_String_Contents, &addr);
  1037.    er = GetStr(MSG_WR_ErrorNoRcpt);
  1038.    if (!*addr) if (MUI_Request(G->App, gui->WI, 0, NULL, GetStr(MSG_WR_NoRcptReqGad), er)) mode = WRITE_HOLD;
  1039.       else return;
  1040.    Busy(GetStr(MSG_BusyComposing), "", 0, 0);
  1041.    get(gui->ST_SUBJECT, MUIA_String_Contents, &comp.Subject);
  1042.    comp.Mode = wr->Mode;
  1043.    comp.OrigMail = wr->Mail;
  1044.    comp.OldSecurity = wr->OldSecurity;
  1045.    wr->ListEntry = NULL;
  1046.    if (*addr) if (!(comp.MailTo = WR_ExpandAddresses(winnum, addr, FALSE, FALSE))) goto skip;
  1047.    if (wr->Mode != NEW_BOUNCE)
  1048.    {
  1049.       get(gui->ST_CC, MUIA_String_Contents, &addr);
  1050.       if (*addr) if (!(comp.MailCC = WR_ExpandAddresses(winnum, addr, FALSE, FALSE))) goto skip;
  1051.       get(gui->ST_BCC, MUIA_String_Contents, &addr);
  1052.       if (*addr) if (!(comp.MailBCC = WR_ExpandAddresses(winnum, addr, FALSE, FALSE))) goto skip;
  1053.       get(gui->ST_FROM, MUIA_String_Contents, &addr);
  1054.       if (*addr) if (!(comp.From = WR_ExpandAddresses(winnum, addr, FALSE, TRUE))) goto skip;
  1055.       get(gui->ST_REPLYTO, MUIA_String_Contents, &addr);
  1056.       if (*addr) if (!(comp.ReplyTo = WR_ExpandAddresses(winnum, addr, FALSE, TRUE))) goto skip;
  1057.       get(gui->ST_EXTHEADER, MUIA_String_Contents, &comp.ExtHeader);
  1058.       if (wr->ListEntry)
  1059.       {
  1060.          if (wr->ListEntry->Address[0]) comp.ReplyTo = StrBufCpy(NULL, wr->ListEntry->Address);
  1061.          if (wr->ListEntry->RealName[0]) comp.From = StrBufCpy(comp.From, BuildAddrName(C->EmailAddress, wr->ListEntry->RealName));
  1062.       }
  1063.       if (wr->MsgID[0]) comp.IRTMsgID = wr->MsgID;
  1064.       comp.Importance = 1-GetMUICycle(gui->CY_IMPORTANCE);
  1065.       if (GetMUICheck(gui->CH_RECEIPT)) comp.Receipt |= 1;
  1066.       if (GetMUICheck(gui->CH_DISPNOTI)) comp.Receipt |= 2;
  1067.       comp.Signature = GetMUIRadio(gui->RA_SIGNATURE);
  1068.       comp.Security = GetMUIRadio(gui->RA_SECURITY);
  1069.       comp.DelSend = GetMUICheck(gui->CH_DELSEND);
  1070.       comp.UserInfo = GetMUICheck(gui->CH_ADDINFO);
  1071.       get(G->WR[winnum]->GUI.LV_ATTACH, MUIA_List_Entries, &att);
  1072.       EditorToFile(gui->TE_EDIT, G->WR_Filename[winnum], G->TTout);
  1073.       comp.FirstPart = BuildPartsList(winnum);
  1074.       comp.FirstPart->TTable = G->TTout;
  1075.    }
  1076.    if (wr->Mode == NEW_EDIT)
  1077.    {
  1078.       struct Mail *edmail = wr->Mail;
  1079.       outfolder = edmail->Folder;
  1080.       if (MailExists(edmail, NULL))
  1081.       {
  1082.          comp.FH = fopen(GetMailFile(NULL, outfolder, edmail), "w");
  1083.          strcpy(mail.MailFile, edmail->MailFile);
  1084.       }
  1085.       else
  1086.       {
  1087.          wr->Mode = NEW_NEW;
  1088.          comp.FH = fopen(MA_NewMailFile(outfolder, mail.MailFile, 0), "w");
  1089.       }
  1090.    }
  1091.    else comp.FH = fopen(MA_NewMailFile(outfolder, mail.MailFile, 0), "w");
  1092.    if (comp.FH)
  1093.    {
  1094.       struct MailInfo *mi;
  1095.       struct ExtendedMail *email;
  1096.       int stat = mode == WRITE_HOLD ? STATUS_HLD : STATUS_WFS;
  1097.       BOOL done = WriteOutMessage(&comp);
  1098.       fclose(comp.FH);
  1099.       if (!done) { DeleteFile(GetMailFile(NULL, outfolder, &mail)); goto skip; }
  1100.       if (wr->Mode != NEW_BOUNCE) EndNotify(&G->WR_NRequest[winnum]);
  1101.       if (email = MA_ExamineMail(outfolder, mail.MailFile, Status[stat], FALSE))
  1102.       {
  1103.          new = AddMailToList((struct Mail *)email, outfolder);
  1104.          MA_FreeEMailStruct(email);
  1105.          if (FO_GetCurrentFolder() == outfolder) DoMethod(G->MA->GUI.NL_MAILS, MUIM_NList_InsertSingle, new, MUIV_NList_Insert_Sorted);
  1106.          MA_SetMailStatus(new, stat);
  1107.          if (wr->Mode == NEW_EDIT)
  1108.          {
  1109.             mi = GetMailInfo(wr->Mail);
  1110.             if (mi->Display) DoMethod(G->MA->GUI.NL_MAILS, MUIM_NList_Remove, mi->Pos);
  1111.             RemoveMailFromList(wr->Mail);
  1112.             wr->Mail = new;
  1113.          }
  1114.       }
  1115.       if (wr->Mode != NEW_NEW)
  1116.       {
  1117.          struct Mail *m, **ml = wr->MList ? wr->MList : mlist;
  1118.          mlist[2] = wr->Mail;
  1119.          for (i = 0; i < (int)ml[0]; i++)
  1120.          {
  1121.             m = ml[i+2];
  1122.             if (!Virtual(m)) if (m->Folder->Type != FT_OUTGOING && m->Folder->Type != FT_SENT)
  1123.             {
  1124.                if (m->Status == STATUS_NEW || m->Status == STATUS_UNR)
  1125.                {
  1126.                   int mdntype = wr->Mode == NEW_REPLY ? MDN_DISP : MDN_PROC;
  1127.                   if (winnum == 2) mdntype |= MDN_AUTOACT;
  1128.                   RE_DoMDN(mdntype, m);
  1129.                }
  1130.                switch (wr->Mode)
  1131.                {
  1132.                   case NEW_REPLY:  MA_SetMailStatus(m, STATUS_RPD);
  1133.                                    DisplayStatistics(m->Folder); break;
  1134.                   case NEW_FORWARD:
  1135.                   case NEW_BOUNCE: MA_SetMailStatus(m, STATUS_FWD);
  1136.                                    DisplayStatistics(m->Folder); break;
  1137.                }
  1138.             }
  1139.          }
  1140.       }
  1141.       switch (wr->Mode)
  1142.       {
  1143.          case NEW_NEW:     AppendLog(10, GetStr(MSG_LOG_Creating),   AddrName(new->To), new->Subject, (void *)att, ""); break;
  1144.          case NEW_REPLY:   AppendLog(11, GetStr(MSG_LOG_Replying),   AddrName(wr->MList[2]->From), wr->MList[2]->Subject, "", ""); break;
  1145.          case NEW_FORWARD: AppendLog(12, GetStr(MSG_LOG_Forwarding), AddrName(wr->MList[2]->From), wr->MList[2]->Subject, AddrName(new->To), ""); break;
  1146.          case NEW_BOUNCE:  AppendLog(13, GetStr(MSG_LOG_Bouncing),   AddrName(wr->Mail->From), wr->Mail->Subject, AddrName(new->To), ""); break;
  1147.          case NEW_EDIT:    AppendLog(14, GetStr(MSG_LOG_Editing),    AddrName(new->From), AddrName(new->To), new->Subject, ""); break;
  1148.       }
  1149.       MA_StartMacro(MACRO_POSTWRITE, itoa(winnum));
  1150.    }
  1151.    else ER_NewError(GetStr(MSG_ER_CreateMailError), NULL, NULL);
  1152.    FreePartsList(comp.FirstPart);
  1153.    if (wr->MList) free(wr->MList);
  1154.    if (mode == WRITE_SEND && new && !G->TR)
  1155.    {
  1156.       set(gui->WI, MUIA_Window_Open, FALSE);
  1157.       mlist[2] = new; MA_SendMList(mlist);
  1158.    }
  1159.    DeleteFile(WR_AutoSaveFile(winnum));
  1160.    DisposeModulePush(&G->WR[winnum]);
  1161. skip:
  1162.    FreeStrBuf(comp.MailTo);
  1163.    FreeStrBuf(comp.MailCC);
  1164.    FreeStrBuf(comp.MailBCC);
  1165.    FreeStrBuf(comp.From);
  1166.    FreeStrBuf(comp.ReplyTo);
  1167.    DisplayStatistics(outfolder);
  1168.    BusyEnd;
  1169. }
  1170. SAVEDS ASM void WR_NewMailFunc(REG(a1) int *arg)
  1171. {
  1172.    WR_NewMail(arg[0], arg[1]);
  1173. }
  1174. MakeHook(WR_NewMailHook, WR_NewMailFunc);
  1175. ///
  1176. /// WR_Cleanup
  1177. //  Terminates file notification and removes temporary files
  1178. void WR_Cleanup(int winnum)
  1179. {
  1180.    int i;
  1181.    struct Attach *att;
  1182.    if (G->WR[winnum]->Mode != NEW_BOUNCE)
  1183.    {
  1184.       EndNotify(&G->WR_NRequest[winnum]);
  1185.       DeleteFile(G->WR_Filename[winnum]);
  1186.       for (i = 0; ; i++)
  1187.       {
  1188.          DoMethod(G->WR[winnum]->GUI.LV_ATTACH, MUIM_List_GetEntry, i, &att);
  1189.          if (!att) break;
  1190.          if (att->IsTemp) DeleteFile(att->FilePath);
  1191.       }
  1192.    }
  1193. }
  1194. ///
  1195. /// WR_CancelFunc
  1196. //  User clicked the Cancel button
  1197. SAVEDS ASM void WR_CancelFunc(REG(a1) int *arg)
  1198. {
  1199.    int haschanged, winnum = *arg;
  1200.    if (G->WR[winnum]->Mode != NEW_BOUNCE)
  1201.    {
  1202.       if (winnum < 2)
  1203.       {
  1204.          get(G->WR[winnum]->GUI.TE_EDIT, MUIA_TextEditor_HasChanged, &haschanged);
  1205.          if (haschanged)
  1206.             switch (MUI_Request(G->App, G->WR[winnum]->GUI.WI, 0, NULL, GetStr(MSG_WR_DiscardChangesGad), GetStr(MSG_WR_DiscardChanges)))
  1207.             {
  1208.                case 0: return;
  1209.                case 1: WR_NewMail(WRITE_QUEUE, winnum);
  1210.                        return;
  1211.                case 2: break;
  1212.             }
  1213.       }
  1214.       WR_Cleanup(winnum);
  1215.    }
  1216.    DisposeModulePush(&G->WR[winnum]);
  1217. }
  1218. MakeHook(WR_CancelHook, WR_CancelFunc);
  1219. ///
  1220. /// WR_SaveAsFunc
  1221. //  Saves contents of internal editor to a file
  1222. SAVEDS ASM void WR_SaveAsFunc(REG(a1) int *arg)
  1223. {
  1224.    int winnum = *arg;
  1225.    set(G->WR[winnum]->GUI.RG_PAGE, MUIA_Group_ActivePage, 0);
  1226.    if (ReqFile(ASL_ATTACH, G->WR[winnum]->GUI.WI, GetStr(MSG_WR_SaveTextAs), 1, C->AttachDir, ""))
  1227.    {
  1228.       char filename[SIZE_PATHFILE];
  1229.       strmfp(filename, G->ASLReq[ASL_ATTACH]->fr_Drawer, G->ASLReq[ASL_ATTACH]->fr_File);
  1230.       EditorToFile(G->WR[winnum]->GUI.TE_EDIT, G->WR_Filename[winnum], NULL);
  1231.       if (!CopyFile(filename, NULL, G->WR_Filename[winnum], NULL))
  1232.          ER_NewError(GetStr(MSG_ER_CantCreateFile), filename, NULL);
  1233.    }
  1234. }
  1235. MakeHook(WR_SaveAsHook, WR_SaveAsFunc);
  1236. ///
  1237. /// WR_Edit
  1238. //  Launches external editor with message text
  1239. SAVEDS ASM void WR_Edit(REG(a1) int *arg)
  1240. {
  1241.    int winnum = *arg;
  1242.    if (*(C->Editor))
  1243.    {
  1244.       char buffer[SIZE_COMMAND+SIZE_PATHFILE];
  1245.       set(G->WR[winnum]->GUI.RG_PAGE, MUIA_Group_ActivePage, 0);
  1246.       EditorToFile(G->WR[winnum]->GUI.TE_EDIT, G->WR_Filename[winnum], NULL);
  1247.       sprintf(buffer,"%s \"%s\"", C->Editor, G->WR_Filename[winnum]);
  1248.       ExecuteCommand(buffer, TRUE, OUT_NIL);
  1249.    }
  1250. }
  1251. MakeHook(WR_EditHook, WR_Edit);
  1252. ///
  1253. /// WR_AddFileFunc
  1254. //  Adds one or more files to the attachment list
  1255. SAVEDS ASM void WR_AddFileFunc(REG(a1) int *arg)
  1256. {
  1257.    int i, winnum = *arg;
  1258.    char filename[SIZE_PATHFILE];
  1259.    struct FileRequester *ar = G->ASLReq[ASL_ATTACH];
  1260.  
  1261.    if (ReqFile(ASL_ATTACH, G->WR[winnum]->GUI.WI, GetStr(MSG_WR_AddFile), 2, C->AttachDir, ""))
  1262.       if (!ar->fr_NumArgs)
  1263.       {
  1264.          strmfp(filename, G->ASLReq[ASL_ATTACH]->fr_Drawer, G->ASLReq[ASL_ATTACH]->fr_File);
  1265.          WR_AddFileToList(winnum, filename, NULL, FALSE);
  1266.       }
  1267.       else for (i = 0; i < ar->fr_NumArgs; i++)
  1268.       {
  1269.          strmfp(filename, G->ASLReq[ASL_ATTACH]->fr_Drawer, G->ASLReq[ASL_ATTACH]->fr_ArgList[i].wa_Name);
  1270.          WR_AddFileToList(winnum, filename, NULL, FALSE);
  1271.       }
  1272. }
  1273. MakeHook(WR_AddFileHook, WR_AddFileFunc);
  1274. ///
  1275. /// WR_AddArchiveFunc
  1276. //  Creates an archive of one or more files and adds it to the attachment list
  1277. SAVEDS ASM void WR_AddArchiveFunc(REG(a1) int *arg)
  1278. {
  1279.    int i, winnum = *arg;
  1280.    static char chr[2] = { 0,0 };
  1281.    char *src, *dst, filename[SIZE_PATHFILE], arcpath[SIZE_PATHFILE], arcname[SIZE_FILE];
  1282.    struct TempFile *tf = NULL;
  1283.    struct FileRequester *ar = G->ASLReq[ASL_ATTACH];
  1284.    BPTR olddir, filedir;
  1285.  
  1286.    if (ReqFile(ASL_ATTACH, G->WR[winnum]->GUI.WI, GetStr(MSG_WR_AddFile), 2, C->AttachDir, ""))
  1287.    {
  1288.       strsfn(ar->fr_ArgList[0].wa_Name, NULL, NULL, arcname, NULL);
  1289.       if (!*arcname) strsfn(ar->fr_ArgList[0].wa_Name, NULL, NULL, NULL, arcname);
  1290.       if (!StringRequest(arcname, SIZE_FILE, GetStr(MSG_WR_CreateArc), GetStr(MSG_WR_CreateArcReq), GetStr(MSG_Okay), NULL, GetStr(MSG_Cancel), FALSE, G->WR[winnum]->GUI.WI)) return;
  1291.       strmfp(filename, C->TempDir, arcname);
  1292.       sprintf(arcpath, strchr(filename, ' ') ? "\"%s\"" : "%s", filename);
  1293.       if (strstr(C->PackerCommand, "%l")) if (tf = OpenTempFile("w"))
  1294.       {
  1295.          for (i = 0; i < ar->fr_NumArgs; i++)
  1296.          {
  1297. //            strmfp(filename, ar->fr_Drawer, ar->fr_ArgList[i].wa_Name);
  1298. //            fprintf(tf->FP, strchr(filename, ' ') ? "\"%s\"\n" : "%s\n", filename);
  1299.             fprintf(tf->FP, strchr(ar->fr_ArgList[i].wa_Name, ' ') ? "\"%s\"\n" : "%s\n", ar->fr_ArgList[i].wa_Name);
  1300.          }
  1301.          fclose(tf->FP); tf->FP = NULL;
  1302.       }
  1303.       dst = AllocStrBuf(SIZE_DEFAULT);
  1304.       for (src = C->PackerCommand; *src; src++)
  1305.          if (*src == '%') switch (*++src)
  1306.          {
  1307.             case '%': dst = StrBufCat(dst, "%"); break;
  1308.             case 'a': dst = StrBufCat(dst, arcpath); break;
  1309.             case 'l': dst = StrBufCat(dst, tf->Filename); break;
  1310.             case 'f': for (i = 0; i < ar->fr_NumArgs; i++)
  1311.                       {
  1312. //                         strcpy(filename, "\"");
  1313. //                         strmfp(&filename[1], ar->fr_Drawer, ar->fr_ArgList[i].wa_Name);
  1314. //                         strcat(filename, "\" ");
  1315.                          sprintf(filename, "\"%s\"", ar->fr_ArgList[i].wa_Name);
  1316.                          dst = StrBufCat(dst, filename);
  1317.                       }
  1318.                       break;
  1319.          }
  1320.          else
  1321.          {
  1322.             chr[0] = *src;
  1323.             dst = StrBufCat(dst, chr);
  1324.          }
  1325.       filedir = Lock(ar->fr_Drawer, ACCESS_READ); olddir = CurrentDir(filedir);
  1326.       ExecuteCommand(dst, FALSE, OUT_NIL);
  1327.       CurrentDir(olddir); UnLock(filedir);
  1328.       FreeStrBuf(dst);
  1329.       CloseTempFile(tf);
  1330.       strcpy(filename, arcpath);
  1331.       if (FileSize(filename) == -1)
  1332.       {
  1333.          sprintf(filename, "%s.lha", arcpath);
  1334.          if (FileSize(filename) == -1)
  1335.          {
  1336.             sprintf(filename, "%s.lzx", arcpath);
  1337.             if (FileSize(filename) == -1)
  1338.                sprintf(filename, "%s.zip", arcpath);
  1339.          }
  1340.       }
  1341.       WR_AddFileToList(winnum, filename, NULL, TRUE);
  1342.    }
  1343. }
  1344. MakeHook(WR_AddArchiveHook, WR_AddArchiveFunc);
  1345. ///
  1346. /// WR_DisplayFile
  1347. //  Displays an attached file using a MIME viewer
  1348. SAVEDS ASM void WR_DisplayFile(REG(a1) int *arg)
  1349. {
  1350.    struct Attach *attach = NULL;
  1351.  
  1352.    DoMethod(G->WR[*arg]->GUI.LV_ATTACH, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &attach);
  1353.    if (attach) RE_DisplayMIME(attach->FilePath, attach->ContentType);
  1354. }
  1355. MakeHook(WR_DisplayFileHook, WR_DisplayFile);
  1356. ///
  1357. /// WR_ChangeSignatureFunc
  1358. //  Changes the current signature
  1359. SAVEDS ASM void WR_ChangeSignatureFunc(REG(a1) int *arg)
  1360. {
  1361.    struct TempFile *tf;
  1362.    int signat = arg[0], winnum = arg[1];
  1363.    char buffer[SIZE_LINE];
  1364.    FILE *in, *out;
  1365.  
  1366.    if (tf = OpenTempFile(NULL))
  1367.    {
  1368.       EditorToFile(G->WR[winnum]->GUI.TE_EDIT, tf->Filename, NULL);
  1369.       if (in = fopen(tf->Filename, "r"))
  1370.       {
  1371.          if (out = fopen(G->WR_Filename[winnum], "w"))
  1372.          {
  1373.             while (fgets(buffer, SIZE_LINE, in))
  1374.                if (strcmp(buffer, "-- \n")) fputs(buffer, out); else break;
  1375.             if (signat) WR_WriteSignature(out, signat-1);
  1376.             fclose(out);
  1377.          }
  1378.          fclose(in);
  1379.       }
  1380.       CloseTempFile(tf);;
  1381.    }
  1382. }
  1383. MakeHook(WR_ChangeSignatureHook, WR_ChangeSignatureFunc);
  1384. ///
  1385.  
  1386. /*** Menus ***/
  1387. /// WR_TransformText
  1388. //  Inserts or pastes text as plain, ROT13 or quoted
  1389. char *WR_TransformText(char *source, int mode, char *qtext)
  1390. {
  1391.    FILE *fp;
  1392.    char *dest = NULL;
  1393.    int ch, i, size = FileSize(source), pos = 0, p = 0, qtextlen = strlen(qtext);
  1394.  
  1395.    if (size > 0)
  1396.    {
  1397.       size += SIZE_DEFAULT;
  1398.       if (mode == ED_INSQUOT || mode == ED_PASQUOT) size += size/20*qtextlen;
  1399.       if (dest = calloc(size, 1))
  1400.       {
  1401.          if (fp = fopen(source, "r"))
  1402.          {
  1403.             while ((ch = fgetc(fp)) != EOF)
  1404.             {
  1405.                if (!pos && (mode == ED_INSQUOT || mode == ED_PASQUOT))
  1406.                {
  1407.                   if (p+qtextlen > size-2) dest = realloc(dest,(size += SIZE_LARGE));
  1408.                   for (i = 0; i < qtextlen; i++) dest[p++] = qtext[i]; dest[p++] = ' ';
  1409.                }
  1410.                if (ch == '\n') pos = 0; else ++pos;
  1411.                if (mode == ED_INSROT13 || mode == ED_PASROT13)
  1412.                {
  1413.                   if (ch >= 'a' && ch <= 'z') if ((ch += 13) > 'z') ch -= 26;
  1414.                   if (ch >= 'A' && ch <= 'Z') if ((ch += 13) > 'Z') ch -= 26;
  1415.                }
  1416.                if (p > size-3) dest = realloc(dest,(size += SIZE_LARGE));
  1417.                dest[p++] = ch;
  1418.             }
  1419.             dest[p] = 0;
  1420.             fclose(fp);
  1421.          }
  1422.       }
  1423.    }
  1424.    return dest;
  1425. }
  1426. ///
  1427. /// WR_InsertSeparator
  1428. //  Inserts a separator bar at the cursor position
  1429. SAVEDS ASM void WR_InsertSeparatorFunc(REG(a1) int *arg)
  1430. {
  1431.    APTR ed = G->WR[arg[1]]->GUI.TE_EDIT;
  1432.    set(ed, MUIA_TextEditor_ImportHook, MUIV_TextEditor_ImportHook_Plain);
  1433.    DoMethod(ed, MUIM_TextEditor_InsertText, arg[0] ? "\n\033c\033[s:18]\n" : "\n\033c\033[s:2]\n");
  1434.    set(ed, MUIA_TextEditor_ImportHook, MUIV_TextEditor_ImportHook_EMail);
  1435. }
  1436. MakeHook(WR_InsertSeparatorHook, WR_InsertSeparatorFunc);
  1437. ///
  1438. /// WR_EditorCmd
  1439. //  Inserts file or clipboard into editor
  1440. SAVEDS ASM void WR_EditorCmd(REG(a1) int *arg)
  1441. {
  1442.    int cmd = arg[0], winnum = arg[1];
  1443.    char *text, filename[SIZE_PATHFILE];
  1444.    struct TempFile *tf;
  1445.    struct WR_ClassData *wr = G->WR[winnum];
  1446.  
  1447.    if (cmd == ED_INSERT || cmd == ED_INSQUOT || cmd == ED_INSROT13 || cmd == ED_OPEN)
  1448.    {
  1449.       if (!ReqFile(ASL_ATTACH, wr->GUI.WI, GetStr(MSG_WR_InsertFile), 0, C->AttachDir, "")) return;
  1450.       strmfp(filename, G->ASLReq[ASL_ATTACH]->fr_Drawer, G->ASLReq[ASL_ATTACH]->fr_File);
  1451.       text = WR_TransformText(filename, cmd, wr->QuoteText);
  1452.    }
  1453.    else
  1454.    {
  1455.       if (!(tf = OpenTempFile("w"))) return;
  1456.       DumpClipboard(tf->FP);
  1457.       fclose(tf->FP); tf->FP = NULL;
  1458.       text = WR_TransformText(tf->Filename, cmd, wr->QuoteText);
  1459.       CloseTempFile(tf);
  1460.    }
  1461.    if (text)
  1462.    {
  1463.       if (cmd == ED_OPEN) DoMethod(wr->GUI.TE_EDIT, MUIM_TextEditor_ClearText);
  1464.       DoMethod(wr->GUI.TE_EDIT, MUIM_TextEditor_InsertText, text);
  1465.       free(text);
  1466.    }
  1467. }
  1468. MakeHook(WR_EditorCmdHook, WR_EditorCmd);
  1469. ///
  1470. /// WR_AddClipboardFunc
  1471. //  Adds contents of clipboard as attachment
  1472. SAVEDS ASM void WR_AddClipboardFunc(REG(a1) int *arg)
  1473. {
  1474.    int winnum = *arg;
  1475.    struct TempFile *tf = OpenTempFile("w");
  1476.    if (DumpClipboard(tf->FP))
  1477.    {
  1478.       fclose(tf->FP); tf->FP = NULL;
  1479.       WR_AddFileToList(winnum, tf->Filename, "clipboard.text", TRUE);
  1480.       free(tf);
  1481.       return;
  1482.    }
  1483.    CloseTempFile(tf);
  1484. }
  1485. MakeHook(WR_AddClipboardHook, WR_AddClipboardFunc);
  1486. ///
  1487. /// WR_AddPGPKeyFunc
  1488. //  Adds ASCII version of user's public PGP key as attachment
  1489. SAVEDS ASM void WR_AddPGPKeyFunc(REG(a1) int *arg)
  1490. {
  1491.    int winnum = *arg;
  1492.    char *myid = *C->MyPGPID ? C->MyPGPID : C->EmailAddress;
  1493.    char options[SIZE_LARGE], *fname = "T:PubKey.asc";
  1494.    sprintf(options, (G->PGPVersion == 5) ? "-x %s -o %s +force +batchmode=1" : "-kxa %s %s +f +bat", myid, fname);
  1495.    if (!PGPCommand((G->PGPVersion == 5) ? "pgpk" : "pgp", options, 0)) if (FileSize(fname) > 0)
  1496.    {
  1497.       WR_AddFileToList(winnum, fname, NULL, TRUE);
  1498.       setstring(G->WR[winnum]->GUI.ST_CTYPE, "application/pgp-keys");
  1499.    }
  1500.    else ER_NewError(GetStr(MSG_ER_ErrorAppendKey), myid, NULL);
  1501. }
  1502. MakeHook(WR_AddPGPKeyHook, WR_AddPGPKeyFunc);
  1503. ///
  1504.  
  1505. /*** Open ***/
  1506. /// WR_Open
  1507. //  Initializes a write window
  1508. int WR_Open(int winnum, BOOL bounce)
  1509. {
  1510.    if (winnum == -1) if (G->WR[winnum = 0]) if (G->WR[winnum = 1]) return -1;
  1511.    G->WR[winnum] = bounce ? WR_NewBounce(winnum) : WR_New(winnum);
  1512.    if (!G->WR[winnum]) return -1;
  1513.    if (!bounce)
  1514.    {
  1515.       struct WR_GUIData *gui = &G->WR[winnum]->GUI;
  1516.       setstring(gui->ST_FROM, BuildAddrName(C->EmailAddress, C->RealName));
  1517.       setstring(gui->ST_REPLYTO, C->ReplyTo);
  1518.       setstring(gui->ST_EXTHEADER, C->ExtraHeaders);
  1519.       setcheckmark(gui->CH_DELSEND, !C->SaveSent);
  1520.       setcheckmark(gui->CH_ADDINFO, C->AddMyInfo);
  1521.    }
  1522.    MA_StartMacro(MACRO_PREWRITE, itoa(winnum));
  1523.    return winnum;
  1524. }
  1525. ///
  1526. /// WR_SetupOldMail
  1527. //  When editing a message, sets write window options to old values
  1528. void WR_SetupOldMail(int winnum)
  1529. {
  1530.    static struct Attach attach;
  1531.    struct Part *part = G->RE[4]->FirstPart->Next;
  1532.  
  1533.    if (part) for (part = part->Next; part; part = part->Next)
  1534.       if (stricmp(part->ContentType, "application/pgp-signature"))
  1535.       {
  1536.          Busy(GetStr(MSG_BusyDecSaving), "", 0, 0);
  1537.          RE_DecodePart(part);
  1538.          clear(&attach, sizeof(struct Attach));
  1539.          attach.Size = part->Size;
  1540.          attach.IsMIME = part->EncodingCode != ENC_UUE;
  1541.          attach.IsTemp = TRUE;
  1542.          if (part->Name) stccpy(attach.Name, part->Name, SIZE_FILE);
  1543.          strcpy(attach.FilePath, part->Filename);
  1544.          *part->Filename = 0;
  1545.          stccpy(attach.ContentType, part->ContentType, SIZE_CTYPE);
  1546.          stccpy(attach.Description, part->Description, SIZE_DEFAULT);
  1547.          DoMethod(G->WR[winnum]->GUI.LV_ATTACH, MUIM_List_InsertSingle, &attach, MUIV_List_Insert_Bottom);
  1548.          BusyEnd;
  1549.       }
  1550. }
  1551. ///
  1552. /// WR_UpdateTitleFunc
  1553. //  Shows cursor coordinates
  1554. SAVEDS ASM void WR_UpdateWTitleFunc(REG(a1) int *arg)
  1555. {
  1556.    struct WR_ClassData *wr = G->WR[*arg];
  1557.    APTR ed = wr->GUI.TE_EDIT;
  1558.  
  1559.    sprintf(wr->WTitle, "%03ld\n%03ld", GetMUI(ed,MUIA_TextEditor_CursorY)+1, GetMUI(ed,MUIA_TextEditor_CursorX)+1);
  1560.    set(wr->GUI.TX_POSI, MUIA_Text_Contents, wr->WTitle);
  1561. }
  1562. MakeHook(WR_UpdateWTitleHook,WR_UpdateWTitleFunc);
  1563. ///
  1564.  
  1565. /*** Hooks ***/
  1566. /// WR_AppFunc
  1567. //  Handles Drag&Drop
  1568. void WR_App(int winnum, struct AppMessage *amsg)
  1569. {
  1570.    struct WBArg *ap;
  1571.    int i, mode;
  1572.    char buf[SIZE_PATHFILE];
  1573.  
  1574.    get(G->WR[winnum]->GUI.RG_PAGE, MUIA_Group_ActivePage, &mode);
  1575.    for (i = 0; i < amsg->am_NumArgs; i++)
  1576.    {
  1577.       ap = &amsg->am_ArgList[i];
  1578.       NameFromLock(ap->wa_Lock, buf, SIZE_PATHFILE);
  1579.       AddPart(buf, ap->wa_Name, SIZE_PATHFILE);
  1580.       if (!mode)
  1581.       {
  1582.          FILE *fh;
  1583.          int len, j, notascii = 0;
  1584.          char buffer[SIZE_LARGE];
  1585.          if (fh = fopen(buf, "r"))
  1586.          {
  1587.             len = fread(buffer, 1, SIZE_LARGE-1, fh);
  1588.             buffer[len] = 0;
  1589.             fclose(fh);
  1590.             for (j = 0; j < len; j++) if ((int)buffer[j] < 32 || (int)buffer[j] > 127) if (buffer[j] != '\t' && buffer[j] != '\n') notascii++;
  1591.             if (notascii) if (len/notascii <= 16) mode = 1;
  1592.          }
  1593.       }
  1594.       if (!mode)
  1595.       {
  1596.          char *text = WR_TransformText(buf, ED_INSERT, "");
  1597.          if (text) DoMethod(G->WR[winnum]->GUI.TE_EDIT, MUIM_TextEditor_InsertText, text);
  1598.          free(text);
  1599.       }
  1600.       else WR_AddFileToList(winnum, buf, NULL, FALSE);
  1601.    }
  1602. }
  1603. SAVEDS ASM LONG WR_AppFunc(REG(a1) ULONG *arg)
  1604. {
  1605.    WR_App((int)arg[1],  (struct AppMessage *)arg[0]);
  1606.    return 0;
  1607. }
  1608. MakeHook(WR_AppHook, WR_AppFunc);
  1609. ///
  1610. /// WR_LV_ConFunc
  1611. //  Attachment listview construct hook
  1612. SAVEDS ASM struct Attach *WR_LV_ConFunc(REG(a1) struct Attach *attach)
  1613. {
  1614.    struct Attach *entry = malloc(sizeof(struct Attach));
  1615.    *entry = *attach;
  1616.    return entry;
  1617. }
  1618. MakeHook(WR_LV_ConFuncHook, WR_LV_ConFunc);
  1619. ///
  1620. /// WR_LV_DspFunc
  1621. //  Attachment listview display hook
  1622. SAVEDS ASM long WR_LV_DspFunc(REG(a2) char **array, REG(a1) struct Attach *entry)
  1623. {
  1624.    static char dispsz[SIZE_SMALL];
  1625.    if (entry)
  1626.    {
  1627.       array[0] = entry->Name;
  1628.       sprintf(array[1] = dispsz, "%d", entry->Size);
  1629.       array[2] = DescribeCT(entry->ContentType);
  1630.       array[3] = entry->IsMIME ? "MIME" : "UU";
  1631.       array[4] = entry->Description;
  1632.    }
  1633.    else 
  1634.    {
  1635.       array[0] = GetStr(MSG_WR_TitleFile); 
  1636.       array[1] = GetStr(MSG_WR_TitleSize);
  1637.       array[2] = GetStr(MSG_WR_TitleContents);
  1638.       array[3] = GetStr(MSG_WR_TitleEncoding);
  1639.       array[4] = GetStr(MSG_WR_TitleDescription);
  1640.    }
  1641.    return 0;
  1642. }
  1643. MakeHook(WR_LV_DspFuncHook, WR_LV_DspFunc);
  1644. ///
  1645.  
  1646. /*** GUI ***/
  1647. /// WR_SharedSetup
  1648. //  Common setup for write and bounce windows
  1649. void WR_SharedSetup(struct WR_ClassData *data, int winnum)
  1650. {
  1651.    SetHelp(data->GUI.ST_TO      ,MSG_HELP_WR_ST_TO      );
  1652.    SetHelp(data->GUI.BT_QUEUE   ,MSG_HELP_WR_BT_QUEUE   );
  1653.    SetHelp(data->GUI.BT_HOLD    ,MSG_HELP_WR_BT_HOLD    );
  1654.    SetHelp(data->GUI.BT_SEND    ,MSG_HELP_WR_BT_SEND    );
  1655.    SetHelp(data->GUI.BT_CANCEL  ,MSG_HELP_WR_BT_CANCEL  );
  1656.    DoMethod(data->GUI.BT_HOLD    ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_NewMailHook,WRITE_HOLD,winnum);
  1657.    DoMethod(data->GUI.BT_QUEUE   ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_NewMailHook,WRITE_QUEUE,winnum);
  1658.    DoMethod(data->GUI.BT_SEND    ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_NewMailHook,WRITE_SEND,winnum);
  1659.    DoMethod(data->GUI.BT_CANCEL  ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_CancelHook,winnum);
  1660.    DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_CloseRequest ,TRUE          ,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_CancelHook,winnum);
  1661. }
  1662. ///
  1663. /// MakeAddressField
  1664. //  Creates a recipient field
  1665. APTR MakeAddressField(APTR *string, char *label, APTR help, int abmode, int winnum, BOOL allowmulti)
  1666. {
  1667.    APTR obj, bt_ver, bt_adr;
  1668.    if (obj = HGroup,
  1669.       GroupSpacing(1),
  1670.       Child, *string = NewObject(CL_DDString->mcc_Class, NULL,
  1671.          MUIA_ControlChar, ShortCut(label),
  1672.          MUIA_UserData, allowmulti,
  1673.       End,
  1674.       Child, bt_ver = PopButton(MUII_ArrowLeft),
  1675.       Child, bt_adr = PopButton(MUII_PopUp),
  1676.    End)
  1677.    {
  1678.       set(bt_ver, MUIA_CycleChain, TRUE);
  1679.       set(bt_adr, MUIA_CycleChain, TRUE);
  1680.       SetHelp(*string,help);
  1681.       SetHelp(bt_ver, MSG_HELP_WR_BT_VER);
  1682.       SetHelp(bt_adr, MSG_HELP_WR_BT_ADR);
  1683.       DoMethod(*string,MUIM_Notify,MUIA_String_Acknowledge,MUIV_EveryTime,MUIV_Notify_Window,5,MUIM_CallHook,&WR_VerifyAutoHook,*string,winnum,!allowmulti);
  1684.       DoMethod(bt_ver,MUIM_Notify,MUIA_Pressed,FALSE,MUIV_Notify_Application,5,MUIM_CallHook,&WR_VerifyManualHook,*string,winnum,!allowmulti);
  1685.       DoMethod(bt_adr,MUIM_Notify,MUIA_Pressed,FALSE,MUIV_Notify_Application,4,MUIM_CallHook,&AB_OpenHook,abmode,winnum);
  1686.    }
  1687.    return obj;
  1688. }
  1689. ///
  1690. /// WR_New
  1691. //  Creates a write window
  1692. enum { WMEN_NEW=1,WMEN_OPEN,WMEN_INSFILE,WMEN_SAVEAS,WMEN_INSQUOT,
  1693.        WMEN_INSROT13,WMEN_EDIT,WMEN_CUT,WMEN_COPY,WMEN_PASTE,
  1694.        WMEN_PASQUOT,WMEN_PASROT13,WMEN_DICT,WMEN_STYLE1,WMEN_STYLE2,WMEN_STYLE3,
  1695.        WMEN_STYLE4,WMEN_EMOT0,WMEN_EMOT1,WMEN_EMOT2,WMEN_EMOT3,WMEN_UNDO,WMEN_REDO,
  1696.        WMEN_AUTOSP,WMEN_SEP0,WMEN_SEP1,WMEN_ADDFILE, WMEN_ADDCLIP, WMEN_ADDPGP,
  1697.        WMEN_DELSEND,WMEN_RECEIPT,WMEN_DISPNOTI,WMEN_ADDINFO,WMEN_IMPORT0,WMEN_IMPORT1,
  1698.        WMEN_IMPORT2,WMEN_SIGN0,WMEN_SIGN1,WMEN_SIGN2,WMEN_SIGN3,
  1699.        WMEN_SECUR0,WMEN_SECUR1,WMEN_SECUR2,WMEN_SECUR3,WMEN_SECUR4 };
  1700. extern long cmap[8];
  1701.  
  1702. struct WR_ClassData *WR_New(int winnum)
  1703. {
  1704.    struct WR_ClassData *data;
  1705.  
  1706.    if (data = calloc(1,sizeof(struct WR_ClassData)))
  1707.    {
  1708.       static char *rtitles[4], *encoding[3], *security[6], *priority[4], *signat[5];
  1709.       static char *emoticons[4] = { ":-)", ":-|", ":-(", ";-)" };
  1710.       APTR mi_copy, mi_cut, mi_redo, mi_undo, mi_bold, mi_italic, mi_underl, mi_color;
  1711.       APTR strip, mi_autospell, mi_delsend, mi_receipt, mi_dispnoti, mi_addinfo;
  1712.       APTR slider = ScrollbarObject, End;
  1713.       APTR tb_butt[13] = { MSG_WR_TBEditor,MSG_WR_TBInsert,MSG_Space,
  1714.                            MSG_WR_TBCut,MSG_WR_TBCopy,MSG_WR_TBPaste,MSG_WR_TBUndo,MSG_Space,
  1715.                            MSG_WR_TBBold,MSG_WR_TBItalic,MSG_WR_TBUnderlined,MSG_WR_TBColored,NULL };
  1716.       APTR tb_help[13] = { MSG_HELP_WR_BT_EDITOR,MSG_HELP_WR_BT_LOAD,NULL,
  1717.                            MSG_HELP_WR_BT_CUT,MSG_HELP_WR_BT_COPY,MSG_HELP_WR_BT_PASTE,MSG_HELP_WR_BT_UNDO,NULL,
  1718.                            MSG_HELP_WR_BT_BOLD,MSG_HELP_WR_BT_ITALIC,MSG_HELP_WR_BT_UNDERL,MSG_HELP_WR_BT_COLOR,NULL };
  1719.       int i, spell;
  1720.       for (i = 0; i < 13; i++) SetupToolbar(&(data->GUI.TB_TOOLBAR[i]), tb_butt[i]?(tb_butt[i]==MSG_Space?"":GetStr(tb_butt[i])):NULL, tb_help[i]?GetStr(tb_help[i]):NULL, (i>=8 && i<=11)?TDF_TOGGLE:0);
  1721.       rtitles[0] = GetStr(MSG_Message);
  1722.       rtitles[1] = GetStr(MSG_Attachments);
  1723.       rtitles[2] = GetStr(MSG_Options);
  1724.       rtitles[3] = NULL;
  1725.       encoding[0] = "Base64/QP";
  1726.       encoding[1] = "UUencode";
  1727.       encoding[2] = NULL;
  1728.       security[0] = GetStr(MSG_WR_SecNone);
  1729.       security[1] = GetStr(MSG_WR_SecSign);
  1730.       security[2] = GetStr(MSG_WR_SecEncrypt);
  1731.       security[3] = GetStr(MSG_WR_SecBoth);
  1732.       security[4] = GetStr(MSG_WR_SecAnon);
  1733.       security[5] = NULL;
  1734.       priority[0] = GetStr(MSG_WR_ImpHigh);
  1735.       priority[1] = GetStr(MSG_WR_ImpNormal);
  1736.       priority[2] = GetStr(MSG_WR_ImpLow);
  1737.       priority[3] = NULL;
  1738.       signat[0] = GetStr(MSG_WR_NoSig);
  1739.       signat[1] = GetStr(MSG_WR_DefSig);
  1740.       signat[2] = GetStr(MSG_WR_AltSig1);
  1741.       signat[3] = GetStr(MSG_WR_AltSig2);
  1742.       signat[4] = NULL;
  1743.       data->GUI.WI = WindowObject,
  1744.          MUIA_Window_Title, GetStr(MSG_WR_WriteWT),
  1745.          MUIA_HelpNode, "WR_W",
  1746.          MUIA_Window_ID, MAKE_ID('W','R','I','T'),
  1747.          MUIA_Window_Menustrip, strip = MenustripObject,
  1748.             MUIA_Family_Child, MenuObject, MUIA_Menu_Title, GetStr(MSG_WR_Text),
  1749.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_New), MUIA_Menuitem_Shortcut,"N", MUIA_UserData,WMEN_NEW, End,
  1750.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_Open), MUIA_Menuitem_Shortcut,"O", MUIA_UserData,WMEN_OPEN, End,
  1751.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_InsertAs),
  1752.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Plain), MUIA_Menuitem_Shortcut,"P", MUIA_UserData,WMEN_INSFILE, End,
  1753.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Quoted), MUIA_UserData,WMEN_INSQUOT, End,
  1754.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_ROT13), MUIA_UserData,WMEN_INSROT13, End,
  1755.                End,
  1756.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,(char)NM_BARLABEL, End,
  1757.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_SaveAs), MUIA_UserData,WMEN_SAVEAS, End,
  1758.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,(char)NM_BARLABEL, End,
  1759.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_LaunchEd), MUIA_Menuitem_Shortcut,"E", MUIA_UserData,WMEN_EDIT, End,
  1760.             End,
  1761.             MUIA_Family_Child, MenuObject, MUIA_Menu_Title, GetStr(MSG_WR_Edit),
  1762.                MUIA_Family_Child, mi_cut = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_MCut), MUIA_Menuitem_Shortcut,"ramiga X", MUIA_Menuitem_CommandString,TRUE, MUIA_UserData,WMEN_CUT, End,
  1763.                MUIA_Family_Child, mi_copy = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_MCopy), MUIA_Menuitem_Shortcut,"ramiga C", MUIA_Menuitem_CommandString,TRUE, MUIA_UserData,WMEN_COPY, End,
  1764.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_MPaste), MUIA_Menuitem_Shortcut,"ramiga V", MUIA_Menuitem_CommandString,TRUE, MUIA_UserData,WMEN_PASTE, End,
  1765.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_PasteAs),
  1766.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Quoted), MUIA_Menuitem_Shortcut,"Q", MUIA_UserData,WMEN_PASQUOT, End,
  1767.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_ROT13), MUIA_UserData,WMEN_PASROT13, End,
  1768.                End,
  1769.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,(char)NM_BARLABEL, End,
  1770.                MUIA_Family_Child, mi_undo = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_MUndo), MUIA_Menuitem_Shortcut,"ramiga Z", MUIA_Menuitem_CommandString,TRUE, MUIA_UserData,WMEN_UNDO, End,
  1771.                MUIA_Family_Child, mi_redo = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Redo), WMEN_REDO, End,
  1772.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,(char)NM_BARLABEL, End,
  1773.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Dictionary), MUIA_Menuitem_Shortcut,"D", MUIA_UserData,WMEN_DICT, End,
  1774.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Textstyle),
  1775.                   MUIA_Family_Child, mi_bold = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Bold), MUIA_Menuitem_Shortcut,"B", MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Toggle,TRUE, MUIA_UserData,WMEN_STYLE1, End,
  1776.                   MUIA_Family_Child, mi_italic = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Italic), MUIA_Menuitem_Shortcut,"I", MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Toggle,TRUE, MUIA_UserData,WMEN_STYLE2, End,
  1777.                   MUIA_Family_Child, mi_underl = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Underlined), MUIA_Menuitem_Shortcut,"U", MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Toggle,TRUE, MUIA_UserData,WMEN_STYLE3, End,
  1778.                   MUIA_Family_Child, mi_color = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Colored), MUIA_Menuitem_Shortcut,"A", MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Toggle,TRUE, MUIA_UserData,WMEN_STYLE4, End,
  1779.                End,
  1780.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Separators),
  1781.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title, GetStr(MSG_WR_Thin), MUIA_Menuitem_Shortcut,"-", MUIA_UserData,WMEN_SEP0, End,
  1782.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title, GetStr(MSG_WR_Thick), MUIA_Menuitem_Shortcut,"=", MUIA_UserData,WMEN_SEP1, End,
  1783.                End,
  1784.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Emoticons),
  1785.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Happy), MUIA_UserData,WMEN_EMOT0, End,
  1786.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Indifferent), MUIA_UserData,WMEN_EMOT1, End,
  1787.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Sad), MUIA_UserData,WMEN_EMOT2, End,
  1788.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_Ironic), MUIA_UserData,WMEN_EMOT3, End,
  1789.                End,
  1790.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,(char)NM_BARLABEL, End,
  1791.                MUIA_Family_Child, mi_autospell = MenuitemObject, MUIA_Menuitem_Title, GetStr(MSG_WR_SpellCheck), MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Toggle,TRUE, MUIA_UserData,WMEN_AUTOSP, End,
  1792.             End,
  1793.             MUIA_Family_Child, MenuObject, MUIA_Menu_Title, GetStr(MSG_Attachments),
  1794.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_MAddFile), MUIA_Menuitem_Shortcut,"F", MUIA_UserData,WMEN_ADDFILE, End,
  1795.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_AddCB), MUIA_UserData,WMEN_ADDCLIP, End,
  1796.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_AddKey), MUIA_UserData,WMEN_ADDPGP, End,
  1797.             End,
  1798.             MUIA_Family_Child, MenuObject, MUIA_Menu_Title, GetStr(MSG_Options),
  1799.                MUIA_Family_Child, mi_delsend = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_MDelSend), MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Toggle,TRUE, MUIA_UserData,WMEN_DELSEND, End,
  1800.                MUIA_Family_Child, mi_receipt = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_MReceipt), MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Toggle,TRUE, MUIA_UserData,WMEN_RECEIPT, End,
  1801.                MUIA_Family_Child, mi_dispnoti= MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_MGetMDN),  MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Toggle,TRUE, MUIA_UserData,WMEN_DISPNOTI, End,
  1802.                MUIA_Family_Child, mi_addinfo = MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_MAddInfo), MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Toggle,TRUE, MUIA_UserData,WMEN_ADDINFO, End,
  1803.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_WR_MImportance),
  1804.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,priority[0], MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x06, MUIA_UserData,WMEN_IMPORT0, End,
  1805.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,priority[1], MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x05, MUIA_Menuitem_Checked,TRUE, MUIA_UserData,WMEN_IMPORT1, End,
  1806.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,priority[2], MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x03, MUIA_UserData,WMEN_IMPORT2, End,
  1807.                End,
  1808.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_CO_CrdSignature),
  1809.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,signat[0], MUIA_Menuitem_Shortcut,"0", MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x0E, MUIA_Menuitem_Checked,!C->UseSignature, MUIA_UserData,WMEN_SIGN0, End,
  1810.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,signat[1], MUIA_Menuitem_Shortcut,"7", MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x0D, MUIA_Menuitem_Checked,C->UseSignature, MUIA_UserData,WMEN_SIGN1, End,
  1811.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,signat[2], MUIA_Menuitem_Shortcut,"8", MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x0B, MUIA_UserData,WMEN_SIGN2, End,
  1812.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,signat[3], MUIA_Menuitem_Shortcut,"9", MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x07, MUIA_UserData,WMEN_SIGN3, End,
  1813.                End,
  1814.                MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,GetStr(MSG_CO_CrdSecurity),
  1815.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,security[0], MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x1E, MUIA_Menuitem_Checked,TRUE, MUIA_UserData,WMEN_SECUR0, End,
  1816.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,security[1], MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x1D, MUIA_UserData,WMEN_SECUR1, End,
  1817.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,security[2], MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x1B, MUIA_UserData,WMEN_SECUR2, End,
  1818.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,security[3], MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x17, MUIA_UserData,WMEN_SECUR3, End,
  1819.                   MUIA_Family_Child, MenuitemObject, MUIA_Menuitem_Title,security[4], MUIA_Menuitem_Checkit,TRUE, MUIA_Menuitem_Exclude,0x0F, MUIA_UserData,WMEN_SECUR4, End,
  1820.                End,
  1821.             End,
  1822.          End,
  1823.          MUIA_Window_AppWindow, TRUE,
  1824.          WindowContents, VGroup,
  1825.             Child, data->GUI.RG_PAGE = RegisterGroup(rtitles),
  1826.                MUIA_CycleChain, 1,
  1827.                Child, VGroup, /* Message */
  1828.                   MUIA_HelpNode, "WR00",
  1829.                   Child, ColGroup(2),
  1830.                      Child, Label(GetStr(MSG_WR_To)),
  1831.                      Child, MakeAddressField(&data->GUI.ST_TO, GetStr(MSG_WR_To), MSG_HELP_WR_ST_TO, ABM_TO, winnum, TRUE),
  1832.                      Child, Label(GetStr(MSG_WR_Subject)),
  1833.                      Child, data->GUI.ST_SUBJECT = MakeString(SIZE_SUBJECT,GetStr(MSG_WR_Subject)),
  1834.                   End,
  1835.                   Child, (C->HideGUIElements & HIDE_TBAR) ?
  1836.                      (RectangleObject, MUIA_ShowMe, FALSE, End) :
  1837.                      (HGroup, GroupSpacing(0),
  1838.                         Child, HGroupV,
  1839.                            Child, data->GUI.TO_TOOLBAR = ToolbarObject,
  1840.                               MUIA_Toolbar_ImageType,      MUIV_Toolbar_ImageType_File,
  1841.                               MUIA_Toolbar_ImageNormal,    "PROGDIR:Icons/Write.toolbar",
  1842.                               MUIA_Toolbar_ImageGhost,     "PROGDIR:Icons/Write_G.toolbar",
  1843.                               MUIA_Toolbar_ImageSelect,    "PROGDIR:Icons/Write_S.toolbar",
  1844.                               MUIA_Toolbar_Description,    data->GUI.TB_TOOLBAR,
  1845.                               MUIA_Font,                   MUIV_Font_Tiny,
  1846.                               MUIA_ShortHelp, TRUE,
  1847.                            End,
  1848.                            Child, HSpace(0),
  1849.                         End,
  1850.                         Child, (C->HideGUIElements & HIDE_XY) ?
  1851.                            HSpace(1) :
  1852.                            (VCenter((data->GUI.TX_POSI = TextObject,
  1853.                               TextFrame,
  1854.                               MUIA_Weight    ,0,
  1855.                               MUIA_Text_Contents, "000\n000",
  1856.                               MUIA_Background,MUII_TextBack,
  1857.                               MUIA_Frame     ,MUIV_Frame_Text,
  1858.                               MUIA_Font      ,MUIV_Font_Tiny,
  1859.                            End))),
  1860.                      End),
  1861.                   Child, HGroup,
  1862.                      MUIA_HelpNode, "EDIT",
  1863.                      MUIA_Group_Spacing, 0,
  1864.                      Child, data->GUI.TE_EDIT = NewObject(CL_TextEditor->mcc_Class,NULL,
  1865.                         InputListFrame,
  1866.                         MUIA_TextEditor_Slider, slider,
  1867.                         MUIA_TextEditor_ColorMap, G->EdColMap,
  1868.                         MUIA_TextEditor_FixedFont, C->FixedFontEdit,
  1869.                         MUIA_TextEditor_WrapBorder, C->EdWrapMode == 1 ? C->EdWrapCol : 0,
  1870.                         MUIA_TextEditor_ExportWrap, C->EdWrapMode == 2 ? C->EdWrapCol : 0,
  1871.                         MUIA_TextEditor_ImportHook, MUIV_TextEditor_ImportHook_EMail,
  1872.                         MUIA_TextEditor_ExportHook, MUIV_TextEditor_ExportHook_EMail,
  1873.                         MUIA_CycleChain, TRUE,
  1874.                      End,
  1875.                      Child, slider,
  1876.                   End,
  1877.                End,
  1878.                Child, VGroup, /* Attachments */
  1879.                   MUIA_HelpNode, "WR01",
  1880.                   Child, ListviewObject,
  1881.                      MUIA_CycleChain, 1,
  1882.                      MUIA_Listview_DragType, 1,
  1883.                      MUIA_Listview_List,data->GUI.LV_ATTACH = NewObject(CL_AttachList->mcc_Class,NULL,
  1884.                         InputListFrame,
  1885.                         MUIA_List_DragSortable ,TRUE,
  1886.                         MUIA_List_Format       ,"D=8 BAR,P=\033r D=8 BAR,D=8 BAR,P=\033c D=8 BAR,",
  1887.                         MUIA_List_Title        ,TRUE,
  1888.                         MUIA_List_ConstructHook,&WR_LV_ConFuncHook,
  1889.                         MUIA_List_DestructHook ,&GeneralDesHook,
  1890.                         MUIA_List_DisplayHook  ,&WR_LV_DspFuncHook, 
  1891.                      End,
  1892.                   End,
  1893.                   Child, ColGroup(4),
  1894.                      Child, data->GUI.BT_ADD     = MakeButton(GetStr(MSG_WR_Add)),
  1895.                      Child, data->GUI.BT_ADDPACK = MakeButton(GetStr(MSG_WR_AddPack)),
  1896.                      Child, data->GUI.BT_DEL     = MakeButton(GetStr(MSG_Del)),
  1897.                      Child, data->GUI.BT_DISPLAY = MakeButton(GetStr(MSG_WR_Display)),
  1898.                   End,
  1899.                   Child, HGroup,
  1900.                      Child, data->GUI.RA_ENCODING = RadioObject,
  1901.                         GroupFrameT(GetStr(MSG_WR_Encoding)),
  1902.                         MUIA_Radio_Entries, encoding,
  1903.                         MUIA_CycleChain, 1,
  1904.                      End,
  1905.                      Child, ColGroup(2),
  1906.                         Child, Label2(GetStr(MSG_WR_ContentType)),
  1907.                         Child, PoplistObject,
  1908.                            MUIA_Popstring_String, data->GUI.ST_CTYPE = MakeString(SIZE_CTYPE,GetStr(MSG_WR_ContentType)),
  1909.                            MUIA_Popstring_Button, PopButton(MUII_PopUp),
  1910.                            MUIA_Poplist_Array   , ContType,
  1911.                         End,
  1912.                         Child, Label2(GetStr(MSG_WR_Description)),
  1913.                         Child, data->GUI.ST_DESC = MakeString(SIZE_DEFAULT,GetStr(MSG_WR_Description)),
  1914.                         Child, HSpace(0),
  1915.                      End,
  1916.                   End,
  1917.                End,
  1918.                Child, VGroup, /* Options */
  1919.                   MUIA_HelpNode, "WR02",
  1920.                   Child, ColGroup(2),
  1921.                      Child, Label(GetStr(MSG_WR_CopyTo)),
  1922.                      Child, MakeAddressField(&data->GUI.ST_CC, GetStr(MSG_WR_CopyTo), MSG_HELP_WR_ST_CC, ABM_CC, winnum, TRUE),
  1923.                      Child, Label(GetStr(MSG_WR_BlindCopyTo)),
  1924.                      Child, MakeAddressField(&data->GUI.ST_BCC, GetStr(MSG_WR_BlindCopyTo), MSG_HELP_WR_ST_BCC, ABM_BCC, winnum, TRUE),
  1925.                      Child, Label(GetStr(MSG_WR_From)),
  1926.                      Child, MakeAddressField(&data->GUI.ST_FROM, GetStr(MSG_WR_From), MSG_HELP_WR_ST_FROM, ABM_FROM, winnum, FALSE),
  1927.                      Child, Label(GetStr(MSG_WR_ReplyTo)),
  1928.                      Child, MakeAddressField(&data->GUI.ST_REPLYTO, GetStr(MSG_WR_ReplyTo), MSG_HELP_WR_ST_REPLYTO, ABM_REPLYTO, winnum, FALSE),
  1929.                      Child, Label(GetStr(MSG_WR_ExtraHeaders)),
  1930.                      Child, data->GUI.ST_EXTHEADER = MakeString(SIZE_LARGE,GetStr(MSG_WR_ExtraHeaders)),
  1931.                   End,
  1932.                   Child, HGroup,
  1933.                      Child, VGroup, GroupFrameT(GetStr(MSG_WR_SendOpt)),
  1934.                         Child, MakeCheckGroup((Object **)&data->GUI.CH_DELSEND, GetStr(MSG_WR_DelSend)),
  1935.                         Child, MakeCheckGroup((Object **)&data->GUI.CH_RECEIPT, GetStr(MSG_WR_Receipt)),
  1936.                         Child, MakeCheckGroup((Object **)&data->GUI.CH_DISPNOTI, GetStr(MSG_WR_GetMDN)),
  1937.                         Child, MakeCheckGroup((Object **)&data->GUI.CH_ADDINFO, GetStr(MSG_WR_AddInfo)),
  1938.                         Child, HGroup,
  1939.                            Child, Label(GetStr(MSG_WR_Importance)),
  1940.                            Child, data->GUI.CY_IMPORTANCE = MakeCycle(priority, GetStr(MSG_WR_Importance)),
  1941.                         End,
  1942.                      End,
  1943.                      Child, HSpace(0),
  1944.                      Child, data->GUI.RA_SIGNATURE = RadioObject, GroupFrameT(GetStr(MSG_WR_Signature)),
  1945.                         MUIA_Radio_Entries, signat,
  1946.                         MUIA_Radio_Active, C->UseSignature ? 1 : 0,
  1947.                         MUIA_CycleChain, 1,
  1948.                      End,
  1949.                      Child, HSpace(0),
  1950.                      Child, data->GUI.RA_SECURITY = RadioObject, GroupFrameT(GetStr(MSG_WR_Security)),
  1951.                         MUIA_Radio_Entries, security,
  1952.                         MUIA_CycleChain, 1,
  1953.                      End,
  1954.                   End,
  1955.                End,
  1956.             End,
  1957.             Child, ColGroup(4),
  1958.                Child, data->GUI.BT_SEND   = MakeButton(GetStr(MSG_WR_Send)),
  1959.                Child, data->GUI.BT_QUEUE  = MakeButton(GetStr(MSG_WR_ToQueue)),
  1960.                Child, data->GUI.BT_HOLD   = MakeButton(GetStr(MSG_WR_Hold)),
  1961.                Child, data->GUI.BT_CANCEL = MakeButton(GetStr(MSG_Cancel)),
  1962.             End,
  1963.          End,
  1964.       End;
  1965.       if (data->GUI.WI)
  1966.       {
  1967.          DoMethod(G->App, OM_ADDMEMBER, data->GUI.WI);
  1968.          set(data->GUI.ST_TO, MUIA_UserData, data->GUI.ST_SUBJECT);
  1969.          set(data->GUI.ST_CC, MUIA_UserData, data->GUI.ST_BCC);
  1970.          set(data->GUI.ST_BCC, MUIA_UserData, data->GUI.ST_FROM);
  1971.          set(data->GUI.ST_FROM, MUIA_UserData, data->GUI.ST_REPLYTO);
  1972.          set(data->GUI.ST_REPLYTO, MUIA_UserData, data->GUI.ST_EXTHEADER);
  1973.          get(data->GUI.TE_EDIT, MUIA_TextEditor_TypeAndSpell, &spell);
  1974.          set(mi_autospell, MUIA_Menuitem_Checked, spell);
  1975.          set(data->GUI.CY_IMPORTANCE, MUIA_Cycle_Active, 1);
  1976.          DoMethod(G->App, MUIM_MultiSet, MUIA_Disabled, TRUE, data->GUI.RA_ENCODING, data->GUI.ST_CTYPE, data->GUI.ST_DESC, data->GUI.BT_DEL, data->GUI.BT_DISPLAY, NULL);
  1977.          SetHelp(data->GUI.ST_SUBJECT   ,MSG_HELP_WR_ST_SUBJECT   );
  1978.          SetHelp(data->GUI.BT_ADD       ,MSG_HELP_WR_BT_ADD       );
  1979.          SetHelp(data->GUI.BT_ADDPACK   ,MSG_HELP_WR_BT_ADDPACK   );
  1980.          SetHelp(data->GUI.BT_DEL       ,MSG_HELP_WR_BT_DEL       );
  1981.          SetHelp(data->GUI.BT_DISPLAY   ,MSG_HELP_WR_BT_DISPLAY   );
  1982.          SetHelp(data->GUI.RA_ENCODING  ,MSG_HELP_WR_RA_ENCODING  );
  1983.          SetHelp(data->GUI.ST_CTYPE     ,MSG_HELP_WR_ST_CTYPE     );
  1984.          SetHelp(data->GUI.ST_DESC      ,MSG_HELP_WR_ST_DESC      );
  1985.          SetHelp(data->GUI.ST_EXTHEADER ,MSG_HELP_WR_ST_EXTHEADER );
  1986.          SetHelp(data->GUI.CH_DELSEND   ,MSG_HELP_WR_CH_DELSEND   );
  1987.          SetHelp(data->GUI.CH_RECEIPT   ,MSG_HELP_WR_CH_RECEIPT   );
  1988.          SetHelp(data->GUI.CH_DISPNOTI  ,MSG_HELP_WR_CH_DISPNOTI  );
  1989.          SetHelp(data->GUI.CH_ADDINFO   ,MSG_HELP_WR_CH_ADDINFO   );
  1990.          SetHelp(data->GUI.CY_IMPORTANCE,MSG_HELP_WR_CY_IMPORTANCE);
  1991.          SetHelp(data->GUI.RA_SIGNATURE ,MSG_HELP_WR_RA_SIGNATURE );
  1992.          SetHelp(data->GUI.RA_SECURITY  ,MSG_HELP_WR_RA_SECURITY  );
  1993.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_NEW      ,data->GUI.TE_EDIT      ,1,MUIM_TextEditor_ClearText);
  1994.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_OPEN     ,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_EditorCmdHook,ED_OPEN,winnum);
  1995.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_INSFILE  ,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_EditorCmdHook,ED_INSERT,winnum);
  1996.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_INSQUOT  ,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_EditorCmdHook,ED_INSQUOT,winnum);
  1997.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_INSROT13 ,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_EditorCmdHook,ED_INSROT13,winnum);
  1998.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_SAVEAS   ,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_SaveAsHook,winnum);
  1999.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_EDIT     ,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_EditHook,winnum);
  2000.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_CUT      ,data->GUI.TE_EDIT      ,3,MUIM_TextEditor_ARexxCmd,"Cut");
  2001.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_COPY     ,data->GUI.TE_EDIT      ,3,MUIM_TextEditor_ARexxCmd,"Copy");
  2002.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_PASTE    ,data->GUI.TE_EDIT      ,3,MUIM_TextEditor_ARexxCmd,"Paste");
  2003.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_PASQUOT  ,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_EditorCmdHook,ED_PASQUOT,winnum);
  2004.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_PASROT13 ,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_EditorCmdHook,ED_PASROT13,winnum);
  2005.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_DICT     ,MUIV_Notify_Application,3,MUIM_CallHook   ,&DI_OpenHook,winnum);
  2006.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_UNDO     ,data->GUI.TE_EDIT      ,3,MUIM_TextEditor_ARexxCmd,"Undo");
  2007.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_REDO     ,data->GUI.TE_EDIT      ,3,MUIM_TextEditor_ARexxCmd,"Redo");
  2008.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_ADDFILE  ,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_AddFileHook,winnum);
  2009.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_ADDCLIP  ,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_AddClipboardHook,winnum);
  2010.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_ADDPGP   ,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_AddPGPKeyHook,winnum);
  2011.          for (i = 0; i < 4; i++) DoMethod(data->GUI.WI,MUIM_Notify,MUIA_Window_MenuAction,WMEN_EMOT0+i,data->GUI.TE_EDIT,2,MUIM_TextEditor_InsertText,emoticons[i]);
  2012.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_SEP0     ,data->GUI.TE_EDIT      ,4,MUIM_CallHook   ,&WR_InsertSeparatorHook,FALSE,winnum);
  2013.          DoMethod(data->GUI.WI         ,MUIM_Notify,MUIA_Window_MenuAction   ,WMEN_SEP1     ,data->GUI.TE_EDIT      ,4,MUIM_CallHook   ,&WR_InsertSeparatorHook,TRUE,winnum);
  2014.          DoMethod(data->GUI.RG_PAGE    ,MUIM_Notify,MUIA_AppMessage          ,MUIV_EveryTime,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_AppHook,MUIV_TriggerValue,winnum);
  2015.          DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify,MUIA_TextEditor_AreaMarked,MUIV_EveryTime,MUIV_Notify_Application,5,MUIM_MultiSet  ,MUIA_Menuitem_Enabled,MUIV_TriggerValue,mi_copy,mi_cut,NULL);
  2016.          if (data->GUI.TO_TOOLBAR)
  2017.          {
  2018.             DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify,MUIA_TextEditor_AreaMarked,MUIV_EveryTime,data->GUI.TO_TOOLBAR  ,6,MUIM_Toolbar_MultiSet,MUIV_Toolbar_Set_Ghosted, MUIV_NotTriggerValue,3,4,-1);
  2019.             DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify,MUIA_TextEditor_UndoAvailable,MUIV_EveryTime,data->GUI.TO_TOOLBAR,4,MUIM_Toolbar_Set,6,MUIV_Toolbar_Set_Ghosted,MUIV_NotTriggerValue);
  2020.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify, 0, MUIV_Toolbar_Notify_Pressed,FALSE, MUIV_Notify_Application,3,MUIM_CallHook,&WR_EditHook,winnum);
  2021.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify, 1, MUIV_Toolbar_Notify_Pressed,FALSE, MUIV_Notify_Application,4,MUIM_CallHook,&WR_EditorCmdHook,ED_INSERT,winnum);
  2022.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify, 3, MUIV_Toolbar_Notify_Pressed,FALSE, data->GUI.TE_EDIT,2,MUIM_TextEditor_ARexxCmd, "CUT");
  2023.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify, 4, MUIV_Toolbar_Notify_Pressed,FALSE, data->GUI.TE_EDIT,2,MUIM_TextEditor_ARexxCmd, "COPY");
  2024.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify, 5, MUIV_Toolbar_Notify_Pressed,FALSE, data->GUI.TE_EDIT,2,MUIM_TextEditor_ARexxCmd, "PASTE");
  2025.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify, 6, MUIV_Toolbar_Notify_Pressed,FALSE, data->GUI.TE_EDIT,2,MUIM_TextEditor_ARexxCmd, "UNDO");
  2026.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify, 8, MUIV_Toolbar_Notify_Pressed,MUIV_EveryTime, data->GUI.TE_EDIT,3,MUIM_Set,MUIA_TextEditor_StyleBold,     MUIV_TriggerValue);
  2027.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify, 9, MUIV_Toolbar_Notify_Pressed,MUIV_EveryTime, data->GUI.TE_EDIT,3,MUIM_Set,MUIA_TextEditor_StyleItalic,   MUIV_TriggerValue);
  2028.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify,10, MUIV_Toolbar_Notify_Pressed,MUIV_EveryTime, data->GUI.TE_EDIT,3,MUIM_Set,MUIA_TextEditor_StyleUnderline,MUIV_TriggerValue);
  2029.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify,11, MUIV_Toolbar_Notify_Pressed,TRUE,           data->GUI.TE_EDIT,3,MUIM_Set,MUIA_TextEditor_Pen,           7);
  2030.             DoMethod(data->GUI.TO_TOOLBAR ,MUIM_Toolbar_Notify,11, MUIV_Toolbar_Notify_Pressed,FALSE,          data->GUI.TE_EDIT,3,MUIM_Set,MUIA_TextEditor_Pen,           0);
  2031.             DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify, MUIA_TextEditor_StyleBold,      MUIV_EveryTime, data->GUI.TO_TOOLBAR,4,MUIM_Toolbar_Set, 8,MUIV_Toolbar_Set_Selected,MUIV_TriggerValue);
  2032.             DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify, MUIA_TextEditor_StyleItalic,    MUIV_EveryTime, data->GUI.TO_TOOLBAR,4,MUIM_Toolbar_Set, 9,MUIV_Toolbar_Set_Selected,MUIV_TriggerValue);
  2033.             DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify, MUIA_TextEditor_StyleUnderline, MUIV_EveryTime, data->GUI.TO_TOOLBAR,4,MUIM_Toolbar_Set,10,MUIV_Toolbar_Set_Selected,MUIV_TriggerValue);
  2034.             DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify, MUIA_TextEditor_Pen,            7,              data->GUI.TO_TOOLBAR,4,MUIM_Toolbar_Set,11,MUIV_Toolbar_Set_Selected,TRUE);
  2035.             DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify, MUIA_TextEditor_Pen,            0,              data->GUI.TO_TOOLBAR,4,MUIM_Toolbar_Set,11,MUIV_Toolbar_Set_Selected,FALSE);
  2036.             DoMethod(mi_bold              ,MUIM_Notify, MUIA_Menuitem_Checked,          MUIV_EveryTime, data->GUI.TO_TOOLBAR,4,MUIM_Toolbar_Set, 8,MUIV_Toolbar_Set_Selected,MUIV_TriggerValue);
  2037.             DoMethod(mi_italic            ,MUIM_Notify, MUIA_Menuitem_Checked,          MUIV_EveryTime, data->GUI.TO_TOOLBAR,4,MUIM_Toolbar_Set, 9,MUIV_Toolbar_Set_Selected,MUIV_TriggerValue);
  2038.             DoMethod(mi_underl            ,MUIM_Notify, MUIA_Menuitem_Checked,          MUIV_EveryTime, data->GUI.TO_TOOLBAR,4,MUIM_Toolbar_Set,10,MUIV_Toolbar_Set_Selected,MUIV_TriggerValue);
  2039.             DoMethod(mi_color             ,MUIM_Notify, MUIA_Menuitem_Checked,          MUIV_EveryTime, data->GUI.TO_TOOLBAR,4,MUIM_Toolbar_Set,11,MUIV_Toolbar_Set_Selected,MUIV_TriggerValue);
  2040.          }
  2041.          DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify,MUIA_TextEditor_UndoAvailable,MUIV_EveryTime,mi_undo            ,3,MUIM_Set,MUIA_Menuitem_Enabled,MUIV_TriggerValue);
  2042.          DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify,MUIA_TextEditor_RedoAvailable,MUIV_EveryTime,mi_redo            ,3,MUIM_Set,MUIA_Menuitem_Enabled,MUIV_TriggerValue);
  2043.          if (data->GUI.TX_POSI)
  2044.          {
  2045.             DoMethod(data->GUI.TE_EDIT ,MUIM_Notify,MUIA_TextEditor_CursorX,MUIV_EveryTime,MUIV_Notify_Application,3,MUIM_CallHook,&WR_UpdateWTitleHook,winnum);
  2046.             DoMethod(data->GUI.TE_EDIT ,MUIM_Notify,MUIA_TextEditor_CursorY,MUIV_EveryTime,MUIV_Notify_Application,3,MUIM_CallHook,&WR_UpdateWTitleHook,winnum);
  2047.          }
  2048.          DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify, MUIA_TextEditor_StyleBold,      MUIV_EveryTime, mi_bold        ,3,MUIM_Set        ,MUIA_Menuitem_Checked,MUIV_TriggerValue);
  2049.          DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify, MUIA_TextEditor_StyleItalic,    MUIV_EveryTime, mi_italic      ,3,MUIM_Set        ,MUIA_Menuitem_Checked,MUIV_TriggerValue);
  2050.          DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify, MUIA_TextEditor_StyleUnderline, MUIV_EveryTime, mi_underl      ,3,MUIM_Set        ,MUIA_Menuitem_Checked,MUIV_TriggerValue);
  2051.          DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify, MUIA_TextEditor_Pen,            7,              mi_color       ,3,MUIM_Set        ,MUIA_Menuitem_Checked,TRUE);
  2052.          DoMethod(data->GUI.TE_EDIT    ,MUIM_Notify, MUIA_TextEditor_Pen,            0,              mi_color       ,3,MUIM_Set        ,MUIA_Menuitem_Checked,FALSE);
  2053.          DoMethod(mi_bold              ,MUIM_Notify, MUIA_Menuitem_Checked,          MUIV_EveryTime, data->GUI.TE_EDIT,3,MUIM_Set,MUIA_TextEditor_StyleBold,     MUIV_TriggerValue);
  2054.          DoMethod(mi_italic            ,MUIM_Notify, MUIA_Menuitem_Checked,          MUIV_EveryTime, data->GUI.TE_EDIT,3,MUIM_Set,MUIA_TextEditor_StyleItalic,   MUIV_TriggerValue);
  2055.          DoMethod(mi_underl            ,MUIM_Notify, MUIA_Menuitem_Checked,          MUIV_EveryTime, data->GUI.TE_EDIT,3,MUIM_Set,MUIA_TextEditor_StyleUnderline,MUIV_TriggerValue);
  2056.          DoMethod(mi_color             ,MUIM_Notify, MUIA_Menuitem_Checked,          TRUE,           data->GUI.TE_EDIT,3,MUIM_Set,MUIA_TextEditor_Pen,           7);
  2057.          DoMethod(mi_color             ,MUIM_Notify, MUIA_Menuitem_Checked,          FALSE,          data->GUI.TE_EDIT,3,MUIM_Set,MUIA_TextEditor_Pen,           0);
  2058.          DoMethod(data->GUI.RG_PAGE    ,MUIM_Notify,MUIA_Group_ActivePage    ,0             ,MUIV_Notify_Window     ,3,MUIM_Set        ,MUIA_Window_NoMenus,FALSE);
  2059.          DoMethod(data->GUI.RG_PAGE    ,MUIM_Notify,MUIA_Group_ActivePage    ,1             ,MUIV_Notify_Window     ,3,MUIM_Set        ,MUIA_Window_NoMenus,TRUE);
  2060.          DoMethod(data->GUI.RG_PAGE    ,MUIM_Notify,MUIA_Group_ActivePage    ,2             ,MUIV_Notify_Window     ,3,MUIM_Set        ,MUIA_Window_NoMenus,TRUE);
  2061.          DoMethod(data->GUI.ST_SUBJECT ,MUIM_Notify,MUIA_String_Acknowledge  ,MUIV_EveryTime,MUIV_Notify_Window     ,3,MUIM_Set        ,MUIA_Window_ActiveObject,data->GUI.TE_EDIT);
  2062.          DoMethod(data->GUI.BT_ADD     ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_AddFileHook,winnum);
  2063.          DoMethod(data->GUI.BT_ADDPACK ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_AddArchiveHook,winnum);
  2064.          DoMethod(data->GUI.BT_DEL     ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,data->GUI.LV_ATTACH    ,2,MUIM_List_Remove,MUIV_List_Remove_Active);
  2065.          DoMethod(data->GUI.BT_DISPLAY ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,data->GUI.LV_ATTACH    ,3,MUIM_CallHook   ,&WR_DisplayFileHook,winnum);
  2066.          DoMethod(data->GUI.LV_ATTACH  ,MUIM_Notify,MUIA_List_Active         ,MUIV_EveryTime,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_GetFileEntryHook,winnum);
  2067.          DoMethod(data->GUI.RA_ENCODING,MUIM_Notify,MUIA_Radio_Active        ,MUIV_EveryTime,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_PutFileEntryHook,winnum);
  2068.          DoMethod(data->GUI.ST_CTYPE   ,MUIM_Notify,MUIA_String_Contents     ,MUIV_EveryTime,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_PutFileEntryHook,winnum);
  2069.          DoMethod(data->GUI.ST_DESC    ,MUIM_Notify,MUIA_String_Contents     ,MUIV_EveryTime,MUIV_Notify_Application,3,MUIM_CallHook   ,&WR_PutFileEntryHook,winnum);
  2070.          DoMethod(data->GUI.RA_SIGNATURE,MUIM_Notify,MUIA_Radio_Active        ,MUIV_EveryTime,MUIV_Notify_Application,4,MUIM_CallHook   ,&WR_ChangeSignatureHook,MUIV_TriggerValue,winnum);
  2071.          DoMethod(data->GUI.CH_DELSEND ,MUIM_Notify,MUIA_Selected            ,MUIV_EveryTime,mi_delsend             ,3,MUIM_Set        ,MUIA_Menuitem_Checked,MUIV_TriggerValue);
  2072.          DoMethod(data->GUI.CH_RECEIPT ,MUIM_Notify,MUIA_Selected            ,MUIV_EveryTime,mi_receipt             ,3,MUIM_Set        ,MUIA_Menuitem_Checked,MUIV_TriggerValue);
  2073.          DoMethod(data->GUI.CH_DISPNOTI,MUIM_Notify,MUIA_Selected            ,MUIV_EveryTime,mi_dispnoti            ,3,MUIM_Set        ,MUIA_Menuitem_Checked,MUIV_TriggerValue);
  2074.          DoMethod(data->GUI.CH_ADDINFO ,MUIM_Notify,MUIA_Selected            ,MUIV_EveryTime,mi_addinfo             ,3,MUIM_Set        ,MUIA_Menuitem_Checked,MUIV_TriggerValue);
  2075.          DoMethod(mi_autospell         ,MUIM_Notify,MUIA_Menuitem_Checked    ,MUIV_EveryTime,data->GUI.TE_EDIT      ,3,MUIM_Set        ,MUIA_TextEditor_TypeAndSpell,MUIV_TriggerValue);
  2076.          DoMethod(mi_delsend           ,MUIM_Notify,MUIA_Menuitem_Checked    ,MUIV_EveryTime,data->GUI.CH_DELSEND   ,3,MUIM_Set        ,MUIA_Selected,MUIV_TriggerValue);
  2077.          DoMethod(mi_receipt           ,MUIM_Notify,MUIA_Menuitem_Checked    ,MUIV_EveryTime,data->GUI.CH_RECEIPT   ,3,MUIM_Set        ,MUIA_Selected,MUIV_TriggerValue);
  2078.          DoMethod(mi_dispnoti          ,MUIM_Notify,MUIA_Menuitem_Checked    ,MUIV_EveryTime,data->GUI.CH_DISPNOTI  ,3,MUIM_Set        ,MUIA_Selected,MUIV_TriggerValue);
  2079.          DoMethod(mi_addinfo           ,MUIM_Notify,MUIA_Menuitem_Checked    ,MUIV_EveryTime,data->GUI.CH_ADDINFO   ,3,MUIM_Set        ,MUIA_Selected,MUIV_TriggerValue);
  2080.          DoMethod(data->GUI.RA_SECURITY,MUIM_Notify,MUIA_Radio_Active        ,4             ,data->GUI.RA_SIGNATURE ,3,MUIM_Set        ,MUIA_Radio_Active,0);
  2081.          DoMethod(data->GUI.RA_SECURITY,MUIM_Notify,MUIA_Radio_Active        ,4             ,data->GUI.CH_ADDINFO   ,3,MUIM_Set        ,MUIA_Selected,FALSE);
  2082.          for (i = 0; i < 3; i++)
  2083.          {
  2084.             DoMethod(data->GUI.CY_IMPORTANCE,MUIM_Notify,MUIA_Cycle_Active     ,i              ,strip                  ,4,MUIM_SetUData,WMEN_IMPORT0+i,MUIA_Menuitem_Checked,TRUE);
  2085.             DoMethod(data->GUI.WI           ,MUIM_Notify,MUIA_Window_MenuAction,WMEN_IMPORT0+i ,data->GUI.CY_IMPORTANCE,3,MUIM_Set     ,MUIA_Cycle_Active,i);
  2086.          }
  2087.          for (i = 0; i < 4; i++) 
  2088.          {
  2089.             DoMethod(data->GUI.RA_SIGNATURE ,MUIM_Notify,MUIA_Radio_Active     ,i              ,strip                  ,4,MUIM_SetUData,WMEN_SIGN0+i,MUIA_Menuitem_Checked,TRUE);
  2090.             DoMethod(data->GUI.WI           ,MUIM_Notify,MUIA_Window_MenuAction,WMEN_SIGN0+i   ,data->GUI.RA_SIGNATURE ,3,MUIM_Set     ,MUIA_Radio_Active,i);
  2091.          }
  2092.          for (i = 0; i < 5; i++) 
  2093.          {
  2094.            DoMethod(data->GUI.WI           ,MUIM_Notify,MUIA_Window_MenuAction,WMEN_SECUR0+i  ,data->GUI.RA_SECURITY  ,3,MUIM_Set     ,MUIA_Radio_Active,i);
  2095.          }
  2096.          WR_SharedSetup(data, winnum);
  2097.          return data;
  2098.       }
  2099.       free(data);
  2100.    }
  2101.    return NULL;
  2102. }
  2103. ///
  2104. /// WR_NewBounce
  2105. //  Creates a bounce window
  2106. struct WR_ClassData *WR_NewBounce(int winnum)
  2107. {
  2108.    struct WR_ClassData *data;
  2109.  
  2110.    if (data = calloc(1,sizeof(struct WR_ClassData)))
  2111.    {
  2112.       data->GUI.WI = WindowObject,
  2113.          MUIA_Window_Title, GetStr(MSG_WR_BounceWT),
  2114.          MUIA_HelpNode, "WR_W",
  2115.          MUIA_Window_ID, MAKE_ID('W','R','I','B'),
  2116.          WindowContents, VGroup, GroupFrame,
  2117.             MUIA_Background, MUII_GroupBack,
  2118.             Child, ColGroup(2),
  2119.                Child, Label2(GetStr(MSG_WR_BounceTo)),
  2120.                Child, MakeAddressField(&data->GUI.ST_TO, GetStr(MSG_WR_BounceTo), MSG_HELP_WR_ST_TO, ABM_TO, winnum, TRUE),
  2121.             End,
  2122.             Child, ColGroup(4),
  2123.                Child, data->GUI.BT_SEND   = MakeButton(GetStr(MSG_WR_Send)),
  2124.                Child, data->GUI.BT_QUEUE  = MakeButton(GetStr(MSG_WR_ToQueue)),
  2125.                Child, data->GUI.BT_HOLD   = MakeButton(GetStr(MSG_WR_Hold)),
  2126.                Child, data->GUI.BT_CANCEL = MakeButton(GetStr(MSG_Cancel)),
  2127.             End,
  2128.          End,
  2129.       End;
  2130.       if (data->GUI.WI)
  2131.       {
  2132.          DoMethod(G->App, OM_ADDMEMBER, data->GUI.WI);
  2133.          set(data->GUI.ST_TO, MUIA_UserData, data->GUI.BT_SEND);
  2134.          WR_SharedSetup(data, winnum);
  2135.          return data;
  2136.       }
  2137.       free(data);
  2138.    }
  2139.    return NULL;
  2140. }
  2141. ///
  2142.