home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / main.c < prev    next >
C/C++ Source or Header  |  1999-02-14  |  148KB  |  4,173 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: Fleet Street Messagereader                                         |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von:  Michael Hohner           | Am: 15.04.93                    |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System: OS/2 2.x PM mit CSet++ 2.1                                        |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:   Messagereader fuer Fido- und Squish-Messagebase           |
  9.  |                                                                           |
  10.  +---------------------------------------------------------------------------+
  11.  | Bemerkungen:                                                              |
  12.  +---------------------------------------------------------------------------*/
  13.  
  14. /*----------------------------- Header-Dateien ------------------------------*/
  15.  
  16. #pragma strings(readonly)
  17.  
  18. #define INCL_GPI
  19. #define INCL_WIN
  20. #define INCL_BASE
  21. #define INCL_SPL
  22. #define INCL_SPLDOSPRINT
  23. #include <os2.h>
  24. #include <io.h>
  25. #include <fcntl.h>
  26. #include <sys/stat.h>
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30.  
  31. #include "main.h"
  32. #include "version.h"
  33. #include "structs.h"
  34. #include "msgheader.h"
  35. #include "areaman/areaman.h"
  36. #include "areaman/folderman.h"
  37. #include "dialogs.h"
  38. #include "dialogids.h"
  39. #include "resids.h"
  40. #include "messages.h"
  41. #include "controls/editwin.h"
  42. #include "controls/statline.h"
  43. #include "controls/msgviewer.h"
  44. #include "controls/toolbar.h"
  45. #include "handlemsg/handlemsg.h"
  46. #include "handlemsg/kludgeapi.h"
  47. #include "init.h"
  48. #include "help.h"
  49. #include "areadlg.h"
  50. #include "areascan.h"
  51. #include "mainwindow.h"
  52. #include "msglist.h"
  53. #include "setupdlg.h"
  54. #include "finddlg.h"
  55. #include "pipeserv.h"
  56. #include "utility.h"
  57. #include "cclist.h"
  58. #include "templatedlg.h"
  59. #include "savemsg.h"
  60. #include "fltv7/fltv7.h"
  61. #include "lookups.h"
  62. #include "attachcheck.h"
  63. #include "threadlist.h"
  64. #include "secwin.h"
  65. #include "ccmanage.h"
  66. #include "rxfolder.h"
  67. #include "rexxexec.h"
  68. #include "markmanage.h"
  69. #include "nlbrowser.h"
  70. #include "nickmanage.h"
  71. #include "nicknames.h"
  72. #include "echomanager.h"
  73. #include "printsetup.h"
  74. #include "toolbarconfig.h"
  75. #include "request.h"
  76. #include "request_manage.h"
  77. #include "dump/expt.h"
  78. #include "util/addrcnv.h"
  79.  
  80. /*--------------------------------- Defines ---------------------------------*/
  81.  
  82. #define REQUIRED_LANGDLL_VERSION  22UL
  83.  
  84. #define WINDOWTITLE "FleetStreet " FLEETVER
  85. #define WINDOWTITLESEC "FleetStreet " FLEETVER " [*]"
  86.  
  87. char pchWindowTitle[100];
  88.  
  89. #define TPLTYPE_NEW      0
  90. #define TPLTYPE_QUOTE    1
  91. #define TPLTYPE_FORWARD  2
  92.  
  93. /*---------------------------- Globale Variablen ----------------------------*/
  94.  
  95. /* Fensterhandles */
  96. HAB anchor = 0;
  97. HMQ queue = NULLHANDLE;
  98. HMODULE hmodLang=NULLHANDLE;
  99. HWND frame = NULLHANDLE;
  100. HWND client = NULLHANDLE;
  101. HWND hwndmenu = NULLHANDLE;
  102. HWND hwndhelp = NULLHANDLE;
  103. PFNWP OldFrameProc=NULL;                    /* Original-WP des Frame     */
  104. volatile BOOL issecondinstance=FALSE;
  105. volatile BOOL isregistered=FALSE;
  106. volatile HWND hwndKludge=NULLHANDLE;
  107. volatile HWND hwndAreaDlg=NULLHANDLE;
  108. HACCEL hAccel1=NULLHANDLE;
  109. HACCEL hAccel2=NULLHANDLE;
  110. HACCEL hAccel3=NULLHANDLE;
  111. volatile ULONG ProfileError;
  112. BOOL bProfileSaved=FALSE;
  113. BOOL bNoHook=FALSE;
  114.  
  115. volatile HWND hwndTemplates = NULLHANDLE;
  116. volatile HWND hwndCCLists = NULLHANDLE;
  117. volatile HWND hwndRxFolder = NULLHANDLE;
  118.  
  119. /* Nodelist-Browser */
  120. volatile HWND hwndNLBrowser = NULLHANDLE;
  121. volatile BOOL bDoingBrowse = FALSE;
  122.  
  123. /* Merker fuer den Exit */
  124. BOOL MailEntered[3]={FALSE, FALSE, FALSE};
  125.  
  126. /* Scan-Thread */
  127. int tidAreaScan=0;
  128. volatile BOOL DoingAreaScan=FALSE;
  129. volatile BOOL StopAreaScan=FALSE;
  130.  
  131. /* Find-Thread */
  132. int tidFind=0;
  133. volatile HWND hwndFindDlg=NULLHANDLE;
  134. volatile HWND hwndFindResults=NULLHANDLE;
  135. volatile BOOL DoingFind=FALSE;
  136. volatile BOOL StopFind=FALSE;
  137.  
  138. /* Worker-Thread */
  139. volatile int  tidWorker=0;
  140. volatile BOOL bDoingWork=FALSE;
  141. volatile BOOL bStopWork = FALSE;
  142.  
  143. /* Thread-Liste */
  144. volatile int tidThreadList=0;
  145. volatile HWND hwndThreadList=NULLHANDLE;
  146. volatile BOOL DoingInsert=FALSE;
  147. volatile BOOL StopInsert=FALSE;
  148.  
  149. /* Message-Liste */
  150. volatile HWND hwndMsgList=NULLHANDLE;
  151.  
  152. /* Request-Dialog */
  153. volatile HWND hwndRequester=NULLHANDLE;
  154.  
  155. volatile BOOL bIgnoreActivate=FALSE;
  156.  
  157. /* Script-Ausfuehrung */
  158. volatile HWND hwndMonitor=NULLHANDLE;
  159. volatile PRXSCRIPT pExecScript=NULL;
  160. volatile int tidRexxExec=0;
  161.  
  162. /* Messages schreiben */
  163. BOOL NewMessage=FALSE;
  164. char NewArea[LEN_AREATAG+1]="";
  165. char *pchXPostList=NULL;
  166. ULONG ulCCSelected=0;
  167. char SaveToName[LEN_USERNAME+1];
  168. char SaveToAddress[LEN_5DADDRESS+1];
  169. int QuotedMsgNum=0;
  170. LONG iptInitialPos=0;
  171. LONG iptInitialPos2=0;
  172. BOOL bTemplateProcessed=TRUE;
  173. ULONG ulTemplateType=0;
  174. BOOL bOldMsgLocal=FALSE;
  175.  
  176. /* Alle Programmoptionen */
  177. AREALIST arealiste;
  178. NICKNAMELIST NickNameList;
  179. USERDATAOPT userdaten;
  180. WINDOWCOLORS windowcolors;
  181. WINDOWFONTS windowfonts;
  182. WINDOWPOSITIONS windowpositions;
  183. PATHNAMES pathnames;
  184. MISCOPTIONS miscoptions;
  185. MACROTABLEOPT macrotable;
  186. GENERALOPT generaloptions;
  187. NODELISTOPT nodelist;
  188. ECHOTOSSOPT echotossoptions;
  189. PDOMAINS domains=NULL;
  190. OUTBOUND outbound[MAX_ADDRESSES];
  191. INTLSETTING intlsetting;
  192. THREADLISTOPTIONS threadlistoptions;
  193. LOOKUPOPTIONS lookupoptions;
  194. RESULTSOPTIONS resultsoptions;
  195. REQUESTOPT requestoptions;
  196. AREALISTOPTIONS arealistoptions;
  197. MSGLISTOPTIONS msglistoptions;
  198. DRIVEREMAP driveremap;
  199. TEMPLATELIST templatelist;
  200. CCANCHOR ccanchor;
  201. SCRIPTLIST scriptlist;
  202. PCCLIST pQuickCCList=NULL;
  203. REXXHOOKS rexxhooks;
  204. FINDJOB FindJob;
  205. MARKERLIST MarkerList;
  206. BOOL bSaveResults;
  207. BROWSEROPTIONS BrowserOptions;
  208. ULONG ulExportOptions;
  209. TOOLBAROPTIONS ToolbarOptions;
  210. ECHOMGROPT EchoMgrOpt;
  211. SEARCHPAR SearchPar;
  212. PRINTSETUP PrintSetup;
  213. TOOLBARCONFIG ToolbarConfig;
  214. OPENWIN OpenWindows;
  215. FOLDERANCHOR FolderAnchor;
  216.  
  217. /* Derzeitige Message */
  218. FTNMESSAGE CurrentMessage;
  219. MSGHEADER CurrentHeader;
  220. char CurrentAddress[LEN_5DADDRESS+1]="";
  221. char CurrentName[LEN_USERNAME+1]="";
  222. char CurrentArea[LEN_AREATAG+1]="";
  223. int  CurrentStatus=PROGSTATUS_NOSETUP;
  224.  
  225. int MonoDisp=FALSE;
  226. int TempMono=FALSE;  /* temp. monospaced (wg. NPD-Flag) */
  227.  
  228. /*--------------------------- Funktionsprototypen ---------------------------*/
  229.  
  230. static MRESULT EXPENTRY clientwndproc(HWND fenster, ULONG message, MPARAM mp1, MPARAM mp2);
  231. static void ProcessCommands(HWND client, USHORT CommandID);
  232. static BOOL ProcessKeys(HWND client, USHORT usVK);
  233. static MRESULT ProcessWorkMessages(HWND hwnd, ULONG message, MPARAM mp1, MPARAM mp2);
  234.  
  235. void StartQuickRexx(USHORT menuID);
  236. static void EditMenuCommands(HWND client, ULONG message);
  237. static int SwitchToArea(char *NewArea);
  238. static void ShutdownProgram(void);
  239. static void HandleAttachAttrib(HWND hwndClient);
  240. static int QuoteCurrentMessage(PWINDOWDATA pWindowData, BOOL bDiffArea, ULONG ulReplyDest,
  241.                                ULONG ulOptions);
  242. static int GetReplyArea(PFTNMESSAGE pCurrentMessage, char *pchDestArea);
  243. static void ShowSecondaryWindows(BOOL bShow);
  244. static BOOL SearchInMessage(HWND hwndClient, PSEARCHPAR pSearchPar);
  245.  
  246. /*---------------------------------- main -----------------------------------*/
  247.  
  248. int main(int argc, char **argv)
  249. {
  250.    QMSG qmsg;
  251.    HELPINIT hinit;
  252.    char pchModError[100];
  253.    HWND hwndAbout=NULLHANDLE;
  254.    HEV hevInit=NULLHANDLE;
  255.    ULONG ulTimerID=0;
  256.    HWND hwnd;
  257.    PFNWP pPrevProc;
  258.    int rc = RET_NOACTION;
  259.    ULONG ulCurrentCP, ulRet;
  260.  
  261.  
  262.    ULONG frameflags= FCF_SIZEBORDER | FCF_MINMAX  | FCF_ICON |
  263.                      FCF_TASKLIST   | FCF_SYSMENU | FCF_TITLEBAR;
  264.  
  265.    INSTALLEXPT("Main");
  266.  
  267.    /* erkennen, ob schon eine Instanz laeuft*/
  268.    if (issecondinstance=AlreadyRunning())
  269.       strcpy(pchWindowTitle, WINDOWTITLESEC);
  270.    else
  271.       strcpy(pchWindowTitle, WINDOWTITLE);
  272.  
  273.    if (!(anchor=WinInitialize(0)))
  274.      return RET_ERROR;                      /* Init fehlgeschlagen       */
  275.  
  276.    if (!(queue=WinCreateMsgQueue(anchor,100)))
  277.      return RET_ERROR;                      /* Queue Init fehlgeschlagen */
  278.  
  279.    DosQueryCp(sizeof(ulCurrentCP), &ulCurrentCP, &ulRet);
  280.    MSG_SetCPInfo(ulCurrentCP);
  281.  
  282.    if (!RegisterSecondaryWindows(anchor))
  283.       return RET_ERROR;
  284.  
  285.    OpenMarkerList(&MarkerList);
  286.  
  287.                                             /* Language-DLL laden        */
  288.    if (DosLoadModule(pchModError, 100, "FLEETLNG", &hmodLang))
  289.    {
  290.                                             /* DLL nicht erfolgreich geladen*/
  291.       WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
  292.                     "FLEETLNG.DLL not found! Run INSTALL.EXE.",
  293.                     "Fatal error!", 50000, MB_OK | MB_ERROR | MB_MOVEABLE);
  294.       return RET_ERROR;
  295.    }
  296.    else
  297.    {
  298.       ULONG (* _System QueryLangVersion)(void);
  299.  
  300.       if (DosQueryProcAddr(hmodLang, 0, "FLTLNG_QueryVersion", (PFN *) &QueryLangVersion) ||
  301.           QueryLangVersion() != REQUIRED_LANGDLL_VERSION)
  302.       {
  303.          /* falsche DLL-Version */
  304.          WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
  305.                        "The language DLL is not suited for this version"
  306.                        " of FleetStreet. Run INSTALL.EXE to update your installation.",
  307.                        "Fatal error!", 50000, MB_OK | MB_ERROR | MB_MOVEABLE);
  308.          return RET_ERROR;
  309.       }
  310.    }
  311.  
  312.    if (!WinRegisterClass(anchor,
  313.                          "FleetStreet",
  314.                          clientwndproc,
  315.                          CS_SIZEREDRAW | CS_SYNCPAINT,
  316.                          sizeof(PVOID)))
  317.       return RET_ERROR;       /* Register fehlgeschlagen */
  318.  
  319.    /* Semaphore fuer Init */
  320.    DosCreateEventSem(NULL, &hevInit, 0, FALSE);
  321.  
  322.    /* Timer starten f. About-Dialog*/
  323.    ulTimerID=WinStartTimer(anchor, 0, 0, 500);
  324.  
  325.    if (LogoDisplayEnabled())
  326.    {
  327.       /* About-Dialog anzeigen */
  328.       hwndAbout=WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP, AboutProc, hmodLang,
  329.                            IDD_HELPABOUT, NULL);
  330.  
  331.       if (!hwndAbout)
  332.          return RET_ERROR;
  333.       else
  334.          WinShowWindow(hwndAbout, TRUE);
  335.  
  336.    }
  337.  
  338.    /* INI-Thread starten */
  339.    ParseArgs(argc, argv);
  340.  
  341.    if (!_beginthread(ReadIniThread, NULL, 65536, &hevInit))
  342.       return RET_ERROR;
  343.  
  344.    /* erste Message-Loop */
  345.    while(WinGetMsg(anchor,&qmsg,0,0,0))
  346.       if ((qmsg.msg != WM_TIMER) || (LONGFROMMP((qmsg.mp1)) != ulTimerID))
  347.          WinDispatchMsg(anchor, &qmsg);
  348.       else
  349.       {
  350.          if (!WinWaitEventSem(hevInit, SEM_IMMEDIATE_RETURN))
  351.          {
  352.             WinStopTimer(anchor, 0, ulTimerID);
  353.             break;
  354.          }
  355.       }
  356.  
  357.    if (hwndAbout)
  358.       WinDestroyWindow(hwndAbout);
  359.    DosCloseEventSem(hevInit);
  360.  
  361.    CreatePipes();
  362.    InitPrintSetup(&PrintSetup, anchor);
  363.  
  364.    memset(&CurrentMessage, 0, sizeof(CurrentMessage));
  365.  
  366.    if (!(windowpositions.mainwindowpos.uchFlags & WINPOS_VALID))
  367.       frameflags |= FCF_SHELLPOSITION;
  368.  
  369.    if (!(frame=WinCreateStdWindow(HWND_DESKTOP,
  370.                                   0,
  371.                                   &frameflags,
  372.                                   "FleetStreet",
  373.                                   pchWindowTitle,
  374.                                   WS_SYNCPAINT,
  375.                                   NULLHANDLE,       /* Ressourcen */
  376.                                   ID_WINDOW,
  377.                                   &client)))
  378.       return RET_ERROR;       /* Fenster kann nicht erzeugt werden */
  379.  
  380. #if 0
  381.    AddToWindowList(frame);
  382. #endif
  383.  
  384.    InitMainWindow(client);
  385.  
  386.    /* Frame-Window ableiten */
  387.    pPrevProc= WinSubclassWindow(frame, ToolbarFrameProc);
  388.    WinSetWindowPtr(frame, 0, (PVOID) pPrevProc);
  389.  
  390.    /* Menue laden */
  391.    if (!(hwndmenu=WinLoadMenu(frame, hmodLang, IDM_MENU)))
  392.       return RET_ERROR;
  393.  
  394.  
  395.    CreateToolbar(frame);
  396.  
  397.    CreateStatusLine(frame);
  398.  
  399.  
  400.    /* Rexx-Menue-Handle holen */
  401.    hwnd = WinWindowFromID(frame, FID_MENU);
  402.    if (hwnd)
  403.    {
  404.       MENUITEM MenuItem;
  405.  
  406.       if (SendMsg(hwnd, MM_QUERYITEM, MPFROM2SHORT(IDM_REXX, FALSE), &MenuItem))
  407.       {
  408.          PWINDOWDATA pWindowData;
  409.  
  410.          pWindowData=(PWINDOWDATA) WinQueryWindowULong(client, QWL_USER);
  411.          pWindowData->hwndRexxMenu = MenuItem.hwndSubMenu;
  412.          UpdateRexxMenu(pWindowData->hwndRexxMenu);
  413.       }
  414.    }
  415.  
  416.    SetFont(hwndmenu, windowfonts.menufont);
  417.    SendMsg(frame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, NULL);
  418.  
  419.    RestoreWinPos(frame, &windowpositions.mainwindowpos, TRUE, TRUE);
  420.  
  421.    WinSendDlgItemMsg(client, IDML_MAINEDIT, MLM_SETTEXTCOLOR,
  422.                      MPFROMLONG(windowcolors.editfore), NULL);
  423.  
  424.    /* Helpsystem initialisieren */
  425.    memset(&hinit, 0, sizeof(hinit));
  426.    hinit.cb=sizeof(HELPINIT);
  427.    hinit.phtHelpTable=(PHELPTABLE) MAKEULONG(FLEET_HELP_TABLE, 0xffff);
  428.    hinit.pszHelpWindowTitle="FleetStreet";     /* Titel der Hilfe */
  429.    hinit.fShowPanelId=CMIC_HIDE_PANEL_ID;
  430.    hinit.pszHelpLibraryName="FLTSTRT.HLP";     /* Helpfile */
  431.  
  432.    if (!(hwndhelp=WinCreateHelpInstance(anchor,&hinit)) ||
  433.        hinit.ulReturnCode)
  434.    {
  435.       char msgbuf[200];
  436.  
  437.       LoadString(IDST_MSG_NOHELP, 200, msgbuf);
  438.  
  439.       WinMessageBox(HWND_DESKTOP,
  440.                     HWND_DESKTOP,
  441.                     msgbuf,
  442.                     NULL,
  443.                     IDD_NOHELP,
  444.                     MB_OK | MB_ERROR | MB_MOVEABLE);
  445.    }
  446.    else
  447.       WinAssociateHelpInstance(hwndhelp, frame);
  448.  
  449.    if (ProfileError)
  450.    {
  451.       if (HandleInitErrors(client, ProfileError) != MBID_OK)
  452.       {
  453.          bProfileSaved = TRUE;
  454.          return RET_ERROR;
  455.       }
  456.  
  457.       if (ProfileError == INIERROR(INIFILE_NEW))
  458.       {
  459.          WinPostMsg(client, WM_COMMAND, MPFROM2SHORT(IDM_OPCONFIG,0),
  460.                     MPFROM2SHORT(CMDSRC_MENU, 0));
  461.  
  462.          if (hwndhelp)
  463.             SendMsg(hwndhelp, HM_GENERAL_HELP, NULL, NULL);
  464.       }
  465.    }
  466.  
  467.    hAccel1=WinLoadAccelTable(anchor, NULLHANDLE, ID_ACCEL1);
  468.    hAccel2=WinLoadAccelTable(anchor, NULLHANDLE, ID_ACCEL2);
  469.    hAccel3=WinLoadAccelTable(anchor, NULLHANDLE, ID_ACCEL3);
  470.  
  471.    StatusChanged(client, CurrentStatus);
  472.    TplSetIntl(&intlsetting);
  473.  
  474.    if (MSG_OpenApi(userdaten.address[0]))
  475.       return RET_ERROR;
  476.  
  477.    if (generaloptions.uselastarea)
  478.       SwitchToArea(miscoptions.lastarearead);
  479.    else
  480.       SwitchToArea(generaloptions.startarea);
  481.  
  482.    if (generaloptions.scanatstartup)
  483.    {
  484.       MarkAllAreas(&arealiste, FOLDERID_ALL, WORK_SCAN);
  485.       if ((tidAreaScan=_beginthread(ScanAreas, NULL, 32768, &arealiste))==-1)
  486.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  487.    }
  488.  
  489.    if (!issecondinstance)
  490.    {
  491.       /* Pipe starten */
  492.       _beginthread(NewPipeServer, NULL, 32768, NULL);
  493.    }
  494.  
  495.    RestoreOpenWindows(&OpenWindows);
  496.    SetFocusControl(client, IDML_MAINEDIT);
  497.  
  498.    /* Message-Loop */
  499.    do
  500.    {
  501.       WinGetMsg(anchor, &qmsg, 0, 0, 0);
  502.       if (qmsg.msg == WM_QUIT &&
  503.           qmsg.hwnd)
  504.          qmsg.msg = WM_CLOSE;
  505.       WinDispatchMsg(anchor, &qmsg);
  506.    } while(qmsg.msg != WM_QUIT);
  507.  
  508.    ShutdownProgram();
  509.  
  510.    MSG_CloseArea(&arealiste, CurrentArea, TRUE, miscoptions.lastreadoffset, &driveremap);
  511.    MSG_CloseApi(&arealiste, &driveremap);
  512.  
  513.    TermPrintSetup(&PrintSetup);
  514.  
  515.    if (hwndhelp)
  516.    {
  517.       WinAssociateHelpInstance(NULLHANDLE, hwndhelp);
  518.       WinDestroyHelpInstance(hwndhelp);
  519.    }
  520.  
  521.    if (hmodLang)
  522.       DosFreeModule(hmodLang);
  523.    if (frame)
  524.       WinDestroyWindow(frame);
  525.    if (queue)
  526.       WinDestroyMsgQueue(queue);
  527.    if (anchor)
  528.       WinTerminate(anchor);
  529.  
  530.    AM_DeleteAllAreas(&arealiste);
  531.    CleanupDomains(&domains);
  532.    CloseMarkerList(&MarkerList);
  533.  
  534.    /* Errorlevel erzeugen */
  535.    if (MailEntered[AREATYPE_NET])
  536.       rc += RET_NEWNETMAIL;
  537.    if (MailEntered[AREATYPE_ECHO])
  538.       rc += RET_NEWECHOMAIL;
  539.    if (MailEntered[AREATYPE_LOCAL])
  540.       rc += RET_NEWLOCALMAIL;
  541.  
  542.    DEINSTALLEXPT;
  543.  
  544.    return rc;
  545. }
  546.  
  547.  
  548. /*------------------------------ clientwndroc  ------------------------------*/
  549. /* Die Fensterprozedur                                                       */
  550. /*---------------------------------------------------------------------------*/
  551.  
  552. static MRESULT EXPENTRY clientwndproc(HWND fenster, ULONG message, MPARAM mp1, MPARAM mp2)
  553. {
  554.    char chBuffer[LEN_AREATAG+1+20];
  555.    AREADEFLIST *zeiger=NULL;
  556.    static char pchFormatScanning[50];
  557.    REQUESTPAR *pRequestPar=NULL;
  558.    ULONG ulResult=0;
  559.    PWINDOWDATA pWindowData;
  560.    BOOL bInsert;
  561.    MESSAGEID MessageID;
  562.    HWND hwnd;
  563.  
  564.    pWindowData=(PWINDOWDATA) WinQueryWindowULong(fenster, QWL_USER);
  565.  
  566.    switch(message)
  567.    {
  568.      /* Bei Drag-Drop aus der Farbpalette */
  569.      case WM_PRESPARAMCHANGED:
  570.         if (((ULONG)mp1)==PP_BACKGROUNDCOLOR) /* andere Aenderungen nicht */
  571.         {                                     /* beachten */
  572.            WinQueryPresParam(fenster,
  573.                              (ULONG)mp1, 0,
  574.                              NULL,
  575.                              sizeof(LONG),
  576.                              (PVOID)&windowcolors.windowback,
  577.                              0);
  578.            WinInvalidateRect(fenster, 0, TRUE);
  579.         }
  580.         return 0;
  581.  
  582.      case WM_MOUSEMOVE:
  583.         DisplayStatusText(0);
  584.         break;
  585.  
  586.      case WM_MINMAXFRAME:
  587.         if (((PSWP)mp1)->fl & SWP_MINIMIZE)
  588.         {
  589.            ShowSecondaryWindows(FALSE);
  590.         }
  591.         if (((PSWP)mp1)->fl & (SWP_MAXIMIZE | SWP_RESTORE))
  592.         {
  593.            ShowSecondaryWindows(TRUE);
  594.         }
  595.         break;
  596.  
  597.      case WM_SAVEAPPLICATION:
  598.         if (!bProfileSaved)
  599.         {
  600.            if (echotossoptions.useechotoss &&
  601.                echotossoptions.pchEchoToss[0])
  602.               WriteEchotoss(&arealiste, echotossoptions.pchEchoToss);
  603.  
  604.            QueryLayout(fenster);
  605.            QueryOpenWindows(&OpenWindows);
  606.            /* zweite Instanz darf nicht speichern */
  607.            if (!issecondinstance)
  608.            {
  609.               SaveIniProfile(anchor);
  610.               if (arealiste.bDirty)
  611.                  SaveIniAreas(anchor);
  612.            }
  613.         }
  614.         break;
  615.  
  616.  
  617.      /* PM soll Hintergrund loeschen */
  618.      case WM_PAINT:
  619.         {
  620.            HPS hps;
  621.            RECTL rectl;
  622.  
  623.            hps=WinBeginPaint(fenster, NULLHANDLE, &rectl);
  624.  
  625.            /* Color Table auf RGB umschalten */
  626.            GpiCreateLogColorTable(hps, 0, LCOLF_RGB, 0, 0, 0);
  627.            WinFillRect(hps, &rectl, windowcolors.windowback);
  628.  
  629.            WinEndPaint(hps);
  630.         }
  631.         return (MRESULT) FALSE;
  632.  
  633.      /* Alle Controls einrichten */
  634.      case WM_CREATE:
  635.         LoadString(IDST_FORMAT_SCANNING, 50, pchFormatScanning);
  636.         break;
  637.  
  638.      /* Menue klappt auf */
  639.      case WM_INITMENU:
  640.         if ((HWND) mp2 != pWindowData->hwndPopup)
  641.            InitMenus(SHORT1FROMMP(mp1), (HWND) mp2);
  642.         break;
  643.  
  644.      case WM_MENUSELECT:
  645.         if ((HWND) mp2 != pWindowData->hwndPopup)
  646.            DisplayMenuHelp(client, SHORT1FROMMP(mp1));
  647.         break;
  648.  
  649.      case WM_CONTEXTMENU:
  650.         if (mp2)
  651.         {
  652.            hwnd=WinQueryFocus(HWND_DESKTOP);
  653.            if (hwnd)
  654.               SendMsg(hwnd, message, mp1, mp2);
  655.         }
  656.         break;
  657.  
  658.      /* Groesse veraendert, anpassen */
  659.      case WM_SIZE:
  660.         FLTLAY_ResizeMainWindow(fenster, SHORT1FROMMP(mp2),SHORT2FROMMP(mp2));
  661.         return (MRESULT) FALSE;
  662.  
  663.      case WM_CLOSE:
  664.         if (tidRexxExec || bDoingWork || DoingFind || bDoingBrowse)
  665.            return (MRESULT) FALSE;
  666.         MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  667.         if (CurrentStatus == PROGSTATUS_EDITING)
  668.         {
  669.            if (MessageBox(client, IDST_MSG_EXITNOSAVE, IDST_TITLE_DISCARD,
  670.                           IDD_EXITNOSAVE,
  671.                           MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2)!=MBID_YES)
  672.               return (MRESULT) FALSE;
  673.         }
  674.         if (!bProfileSaved && CurrentStatus != PROGSTATUS_CLEANUP)
  675.         {
  676.            if (echotossoptions.useechotoss &&
  677.                echotossoptions.pchEchoToss[0])
  678.               if (WriteEchotoss(&arealiste, echotossoptions.pchEchoToss))
  679.               {
  680.                  MessageBox(client, IDST_MSG_ETOSSERROR, 0, IDD_ETOSSERROR,
  681.                             MB_ERROR | MB_OK);
  682.                  return (MRESULT) FALSE;
  683.               }
  684.  
  685.            QueryLayout(fenster);
  686.            QueryOpenWindows(&OpenWindows);
  687.            CurrentStatus = PROGSTATUS_CLEANUP;
  688.            UpdateDisplay(FALSE, FALSE);
  689.            ShutdownProgram();
  690.            StatusChanged(client, CurrentStatus);
  691.  
  692.            if (!bNoHook && rexxhooks.ulExitID && !StartRexxScript(rexxhooks.ulExitID, NULL))
  693.            {
  694.               pWindowData->ulCurrentHook = CURRENTHOOK_EXIT;
  695.               return (MRESULT) FALSE;
  696.            }
  697.  
  698.            if (!issecondinstance)
  699.            {
  700.               _beginthread(SaveIniProfileThread, NULL, 32768, &queue);
  701.            }
  702.            else
  703.               break;
  704.         }
  705.         return (MRESULT) FALSE;
  706.  
  707.      case KM_KLUDGEWNDCLOSE:
  708.         WinDestroyWindow(hwndKludge);
  709.         hwndKludge=NULLHANDLE;
  710.         if (pWindowData->pArea &&
  711.             pWindowData->pArea->maxmessages>0)
  712.            WinSendDlgItemMsg(frame, FID_TOOLBAR, TBM_ENABLECMD, MPFROMLONG(IDB_SHOWKLUDGES), NULL);
  713.         break;
  714.  
  715.      case FM_FINDRESULTSCLOSE:
  716.         WinDestroyWindow(hwndFindResults);
  717.         hwndFindResults=NULLHANDLE;
  718.         break;
  719.  
  720.      case MSGLM_CLOSE:
  721.         WinDestroyWindow(hwndMsgList);
  722.         hwndMsgList=NULLHANDLE;
  723.         break;
  724.  
  725.      case TM_THREADLISTCLOSE:
  726.          WinDestroyWindow(hwndThreadList);
  727.          hwndThreadList=NULLHANDLE;
  728.          break;
  729.  
  730.      case ALM_CLOSE:
  731.         if (hwndAreaDlg == (HWND) mp1)
  732.         {
  733.            WinDestroyWindow(hwndAreaDlg);
  734.            hwndAreaDlg = NULLHANDLE;
  735.         }
  736.         break;
  737.  
  738.      case TPLF_CLOSE:
  739.         WinDestroyWindow(hwndTemplates);
  740.         hwndTemplates=NULLHANDLE;
  741.         break;
  742.  
  743.      case CCFM_CLOSE:
  744.         WinDestroyWindow(hwndCCLists);
  745.         hwndCCLists=NULLHANDLE;
  746.         break;
  747.  
  748.      case RXF_CLOSE:
  749.         WinDestroyWindow(hwndRxFolder);
  750.         hwndRxFolder=NULLHANDLE;
  751.         break;
  752.  
  753.      case BRSM_CLOSE:
  754.         if (hwndNLBrowser)
  755.         {
  756.            WinDestroyWindow(hwndNLBrowser);
  757.            hwndNLBrowser=NULLHANDLE;
  758.         }
  759.         break;
  760.  
  761.      case REXXM_CLOSE:
  762.         WinDestroyWindow((HWND) mp1);
  763.         if (hwndRxFolder)
  764.            SendMsg(hwndRxFolder, REXXM_CLOSE, mp1, mp2);
  765.         hwndMonitor = NULLHANDLE;
  766.         switch (pWindowData->ulCurrentHook)
  767.         {
  768.            case CURRENTHOOK_NONE:
  769.               break;
  770.  
  771.            case CURRENTHOOK_PRESAVE:
  772.               pWindowData->ulCurrentHook = CURRENTHOOK_NONE;
  773.               bNoHook=TRUE;
  774.               ProcessCommands(client, IDB_OK);
  775.               bNoHook=FALSE;
  776.               break;
  777.  
  778.            case CURRENTHOOK_EXIT:
  779.               pWindowData->ulCurrentHook = CURRENTHOOK_NONE;
  780.               CurrentStatus = PROGSTATUS_READING;
  781.               bNoHook=TRUE;
  782.               SendMsg(client, WM_CLOSE, NULL, NULL);
  783.               bNoHook=FALSE;
  784.               break;
  785.         }
  786.         break;
  787.  
  788.      case RXM_UPDATEMENU:
  789.         if (pWindowData->hwndRexxMenu)
  790.            UpdateRexxMenu(pWindowData->hwndRexxMenu);
  791.         break;
  792.  
  793.      case ALM_SWITCHAREA:
  794.         /* Source-Window */
  795.         pWindowData->ulSourceWindow = SOURCEWIN_AREA;
  796.  
  797.         if (CurrentStatus == PROGSTATUS_READING &&
  798.             stricmp(CurrentArea, (PCHAR) mp1))
  799.         {
  800.            MSGLISTPAR MsgListPar;
  801.  
  802.  
  803.            MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  804.            strcpy(MessageID.pchAreaTag, CurrentArea);
  805.            MessageID.ulMsgID=pWindowData->ulCurrentID;
  806.            SendMsg(client, WORKM_READ, &MessageID, NULL);
  807.  
  808.            /* Aktuelle Area schliessen */
  809.            MSG_CloseArea(&arealiste, CurrentArea, TRUE, miscoptions.lastreadoffset, &driveremap);
  810.  
  811.            /* Neue Area oeffnen */
  812.            NewMessage=FALSE;
  813.            SwitchToArea(mp1);
  814.            MsgListPar.msgnum=MSG_MsgnToUid(&arealiste, CurrentArea, QueryCurrent(&arealiste, CurrentArea));
  815.            pWindowData->ulCurrentID= MsgListPar.msgnum;
  816.            if (hwndThreadList)
  817.               SendMsg(hwndThreadList, TM_REREADTHREADS, &MsgListPar, NULL);
  818.            if (hwndMsgList)
  819.               SendMsg(hwndMsgList, TM_REREADTHREADS, &MsgListPar, NULL);
  820.         }
  821.         break;
  822.  
  823.      case WM_DESTROY:
  824.         if (pWindowData->hwndPopup)
  825.            WinDestroyWindow(pWindowData->hwndPopup);
  826.         break;
  827.  
  828.      case WM_CONTROLPOINTER:
  829.         DisplayStatusText(SHORT1FROMMP(mp1));
  830.         break;
  831.  
  832.      case WM_COMMAND:
  833.         ProcessCommands(fenster, SHORT1FROMMP(mp1));
  834.         return (MRESULT) FALSE;
  835.  
  836.      case WM_CONTROL:
  837.         switch (SHORT1FROMMP(mp1))
  838.         {
  839.            case FID_STATUSLINE:
  840.               switch(SHORT2FROMMP(mp1))
  841.               {
  842.                  case STLN_CONTEXTMENU:
  843.                     break;
  844.  
  845.                  case STLN_OPEN:
  846.                     if ((ULONG) mp2 == pWindowData->idAddressField)
  847.                        ProcessCommands(client, IDM_OPNAMEADDR);
  848.                     if ((ULONG) mp2 == pWindowData->idCheckField &&
  849.                         CurrentStatus == PROGSTATUS_READING)
  850.                        ProcessCommands(client, IDA_MARKTOGGLE);
  851.                     if ((ULONG) mp2 == pWindowData->idProgressField)
  852.                        ProcessCommands(client, IDA_CANCEL);
  853.                     break;
  854.  
  855.                  default:
  856.                     break;
  857.               }
  858.               break;
  859.  
  860.            case FID_TOOLBAR:
  861.               switch(SHORT2FROMMP(mp1))
  862.               {
  863.                  case TBN_CONTEXTMENU:
  864.                     OpenToolbarContext(client, pWindowData, (ULONG) mp2);
  865.                     break;
  866.  
  867.                  default:
  868.                     break;
  869.               }
  870.               break;
  871.  
  872.            case IDE_TOADDRESS:
  873.               if (SHORT2FROMMP(mp1)==EN_SETFOCUS)
  874.                  SendMsg((HWND)mp2, EM_SETSEL, MPFROM2SHORT(0, LEN_5DADDRESS+1),
  875.                             NULL);
  876.               if (SHORT2FROMMP(mp1)==EN_KILLFOCUS && !ulCCSelected && !pQuickCCList &&
  877.                   CurrentStatus == PROGSTATUS_EDITING)
  878.               {
  879.                  char pchTemp[LEN_5DADDRESS+1];
  880.                  FTNADDRESS tempAddr, tempAddr2;
  881.                  int iMatch;
  882.  
  883.                  WinQueryWindowText((HWND)mp2, LEN_5DADDRESS+1, pchTemp);
  884.                  StringToNetAddr(pchTemp, &tempAddr, CurrentAddress);
  885.                  WinSetWindowText((HWND)mp2, NetAddrToString(pchTemp, &tempAddr));
  886.                  WinQueryWindowText(WinWindowFromID(client, IDE_FROMADDRESS), LEN_5DADDRESS+1, pchTemp);
  887.                  StringToNetAddr(pchTemp, &tempAddr2, NULL);
  888.                  iMatch = MSG_MatchAddress(&tempAddr, &userdaten, &tempAddr2);
  889.                  if (iMatch>=0)
  890.                     WinSetDlgItemText(client, IDE_FROMADDRESS, userdaten.address[iMatch]);
  891.               }
  892.               if (SHORT2FROMMP(mp1) == EN_CONTEXTMENU)
  893.               {
  894.                  pWindowData->usPopupControl = SHORT1FROMMP(mp1);
  895.  
  896.                  OpenEditPopup(client, pWindowData, (BOOL) mp2);
  897.                  return 0;
  898.               }
  899.               if (SHORT2FROMMP(mp1) == EN_NODEDROPPED && mp2)
  900.               {
  901.                  PCHAR pchTemp=strchr((PCHAR)mp2, ' ');
  902.                  if (pchTemp)
  903.                  {
  904.                     pchTemp++;
  905.                     WinSetDlgItemText(client, IDE_TONAME, pchTemp);
  906.                  }
  907.               }
  908.               break;
  909.  
  910.            case IDE_FROMADDRESS:
  911.               if (SHORT2FROMMP(mp1)==EN_SETFOCUS)
  912.                  SendMsg((HWND)mp2, EM_SETSEL, MPFROM2SHORT(0, LEN_5DADDRESS+1),
  913.                             NULL);
  914.               if (SHORT2FROMMP(mp1)==EN_KILLFOCUS && CurrentStatus == PROGSTATUS_EDITING)
  915.               {
  916.                  char pchTemp[LEN_5DADDRESS+1];
  917.                  FTNADDRESS tempAddr;
  918.  
  919.                  WinQueryWindowText((HWND)mp2, LEN_5DADDRESS+1, pchTemp);
  920.                  StringToNetAddr(pchTemp, &tempAddr, CurrentAddress);
  921.                  WinSetWindowText((HWND)mp2, NetAddrToString(pchTemp, &tempAddr));
  922.               }
  923.               if (SHORT2FROMMP(mp1) == EN_CONTEXTMENU)
  924.               {
  925.                  pWindowData->usPopupControl = SHORT1FROMMP(mp1);
  926.  
  927.                  OpenEditPopup(client, pWindowData, (BOOL) mp2);
  928.                  return 0;
  929.               }
  930.               if (SHORT2FROMMP(mp1) == EN_NODEDROPPED && mp2)
  931.               {
  932.                  PCHAR pchTemp=strchr((PCHAR)mp2, ' ');
  933.                  if (pchTemp)
  934.                  {
  935.                     pchTemp++;
  936.                     WinSetDlgItemText(client, IDE_FROMNAME, pchTemp);
  937.                  }
  938.               }
  939.               break;
  940.  
  941.            case IDE_SUBJTEXT:
  942.               if (SHORT2FROMMP(mp1) == EN_CONTEXTMENU)
  943.               {
  944.                  pWindowData->usPopupControl = SHORT1FROMMP(mp1);
  945.  
  946.                  OpenEditPopup(client, pWindowData, (BOOL) mp2);
  947.                  return 0;
  948.               }
  949.               if (SHORT2FROMMP(mp1) == EN_FILEATTACH)
  950.               {
  951.                  CurrentHeader.ulAttrib &= ~ATTRIB_FILEATTACHED;
  952.                  WinPostMsg(client, WM_COMMAND, MPFROMSHORT(IDA_TOGGLE_FILE),
  953.                             MPFROM2SHORT(CMDSRC_ACCELERATOR, FALSE));
  954.                  return 0;
  955.               }
  956.               break;
  957.  
  958.            case IDE_FROMNAME:
  959.            case IDE_TONAME:
  960.               if (SHORT2FROMMP(mp1) == EN_CONTEXTMENU)
  961.               {
  962.                  pWindowData->usPopupControl = SHORT1FROMMP(mp1);
  963.  
  964.                  OpenEditPopup(client, pWindowData, (BOOL) mp2);
  965.                  return 0;
  966.               }
  967.               if (SHORT2FROMMP(mp1) == EN_NODEDROPPED && mp2)
  968.               {
  969.                  PCHAR pchTemp=strdup((PCHAR)mp2);
  970.                  PCHAR pchTemp2=strchr(pchTemp, ' ');
  971.                  if (pchTemp2)
  972.                  {
  973.                     *pchTemp2=0;
  974.                     if (SHORT1FROMMP(mp1) == IDE_FROMNAME)
  975.                        WinSetDlgItemText(client, IDE_FROMADDRESS, pchTemp);
  976.                     else
  977.                        WinSetDlgItemText(client, IDE_TOADDRESS, pchTemp);
  978.                  }
  979.                  free(pchTemp);
  980.               }
  981.               break;
  982.  
  983.            case IDML_MAINEDIT:
  984.               if (SHORT2FROMMP(mp1)==MLN_SETFOCUS)
  985.               {
  986.                  if (!bTemplateProcessed)
  987.                  {
  988.                     char pchTemp[LEN_5DADDRESS+1];
  989.  
  990.                     /* Template fertig verarbeiten und einsetzen */
  991.                     WinQueryDlgItemText(client, IDE_FROMNAME, LEN_USERNAME, CurrentHeader.pchFromName);
  992.                     if (!ulCCSelected && !pQuickCCList)
  993.                        WinQueryDlgItemText(client, IDE_TONAME, LEN_USERNAME, CurrentHeader.pchToName);
  994.                     else
  995.                        CurrentHeader.pchToName[0]='\0';
  996.                     WinQueryDlgItemText(client, IDE_FROMADDRESS, LEN_5DADDRESS, pchTemp);
  997.                     StringToNetAddr(pchTemp, &CurrentHeader.FromAddress, CurrentAddress);
  998.                     WinQueryDlgItemText(client, IDE_TOADDRESS, LEN_5DADDRESS, pchTemp);
  999.                     StringToNetAddr(pchTemp, &CurrentHeader.ToAddress, CurrentAddress);
  1000.                     switch(ulTemplateType)
  1001.                     {
  1002.                        case TPLTYPE_NEW:
  1003.                           MSG_NewMessageStep2(&templatelist, &arealiste, NewArea,
  1004.                                               &CurrentMessage, &CurrentHeader, &iptInitialPos);
  1005.                           break;
  1006.  
  1007.                        case TPLTYPE_QUOTE:
  1008.                           MSG_QuoteMessageStep2(&templatelist, &CurrentMessage, &CurrentHeader, &arealiste,
  1009.                                                 CurrentArea, NewArea,
  1010.                                                 CurrentName, &iptInitialPos);
  1011.                           break;
  1012.  
  1013.                        case TPLTYPE_FORWARD:
  1014.                           MSG_ForwardMessageStep2(&templatelist, &CurrentMessage, &CurrentHeader,
  1015.                                                   &arealiste, NewArea, CurrentName, &iptInitialPos);
  1016.                           break;
  1017.  
  1018.                        default:
  1019.                           break;
  1020.                     }
  1021.                     DisplayMsgText(client, &CurrentMessage);
  1022.                     WinSendDlgItemMsg(client, IDML_MAINEDIT, MLM_SETSEL,
  1023.                                       MPFROMLONG(iptInitialPos+iptInitialPos2),
  1024.                                       MPFROMLONG(iptInitialPos+iptInitialPos2));
  1025.                     bTemplateProcessed=TRUE;
  1026.                  }
  1027.               }
  1028.               if (SHORT2FROMMP(mp1)==MLN_CONTEXTMENU)
  1029.               {
  1030.                  pWindowData->usPopupControl = SHORT1FROMMP(mp1);
  1031.  
  1032.  
  1033.                  OpenEditPopup(client, pWindowData, (BOOL) mp2);
  1034.                  return 0;
  1035.               }
  1036.               if (SHORT2FROMMP(mp1)==MLN_FILEDROPPED)
  1037.               {
  1038.                  /* File importieren */
  1039.                  switch(ImportFile(client, (PCHAR) mp2,
  1040.                         !(pWindowData->pArea->areadata.ulAreaOpt & AREAOPT_HIGHASCII), FALSE))
  1041.                  {
  1042.                     /* Lesefehler */
  1043.                     case 1:
  1044.                        MessageBox(client, IDST_MSG_ERRORLOAD, 0, IDD_ERRORLOAD,
  1045.                                   MB_OK | MB_ERROR);
  1046.                        break;
  1047.  
  1048.                     /* Falscher Filename usw. */
  1049.                     case 2:
  1050.                        MessageBox(client, IDST_MSG_INVALIDFILE, 0, IDD_INVALIDFILE,
  1051.                                   MB_OK | MB_ERROR);
  1052.                        break;
  1053.  
  1054.                     /* File leer */
  1055.                     case 3:
  1056.                        MessageBox(client, IDST_MSG_EMPTYFILE, 0, IDD_EMPTYFILE,
  1057.                                   MB_OK | MB_ERROR);
  1058.                        break;
  1059.  
  1060.                     default:
  1061.                        break;
  1062.                  }
  1063.                  free(mp2);
  1064.               }
  1065.               if (SHORT2FROMMP(mp1)==MSGVN_PRINTCURRENT)
  1066.               {
  1067.                  PPRINTDEST pPrintDest = (PPRINTDEST) mp2;
  1068.                  PWORKDATA pWorkData;
  1069.  
  1070.                  /* Aktuelle Message drucken, mp2 ist PPRINTDEST */
  1071.                  if (CurrentStatus==PROGSTATUS_READING &&
  1072.                      pWindowData->pArea &&
  1073.                      pWindowData->pArea->maxmessages > 0)
  1074.                  {
  1075.                     pWorkData=malloc(sizeof(WORKDATA));
  1076.  
  1077.                     pWorkData->next=NULL;
  1078.                     pWorkData->MsgIDArray=malloc(sizeof(ULONG));
  1079.                     pWorkData->MsgIDArray[0] = pWindowData->ulCurrentID;
  1080.                     pWorkData->ulArraySize = 1;
  1081.                     pWorkData->flWorkToDo=WORK_PRINT;
  1082.                     pWorkData->pPrintDest = malloc(pPrintDest->cb);
  1083.                     memcpy(pWorkData->pPrintDest, pPrintDest, pPrintDest->cb);
  1084.                     strcpy(pWorkData->pchSrcArea, CurrentArea);
  1085.                     bDoingWork=TRUE;
  1086.                     _beginthread(WorkerThread, NULL, 32768, pWorkData);
  1087.                     Notify(client, IDST_NOT_PRINTED);
  1088.                  }
  1089.               }
  1090.               if (SHORT2FROMMP(mp1)==MSGVN_DISCARDCURRENT)
  1091.               {
  1092.                  /* Aktuelle Message loeschen */
  1093.                  if (CurrentStatus==PROGSTATUS_READING &&
  1094.                      pWindowData->pArea &&
  1095.                      pWindowData->pArea->maxmessages > 0)
  1096.                  {
  1097.                     int rc;
  1098.  
  1099.                     if (generaloptions.safety & SAFETY_SHREDMSG)
  1100.                     {
  1101.                        if (MessageBox(client, IDST_MSG_DELETE, IDST_TITLE_DELETE,
  1102.                                       IDD_DELETE, MB_YESNO | MB_ICONEXCLAMATION)!=MBID_YES)
  1103.                           break;
  1104.                     }
  1105.                     /* Momentane Message loeschen */
  1106.                     rc=MSG_KillMessage(&arealiste, CurrentArea, 0, &driveremap, SendKillMessage);
  1107.                     if (rc != OK &&
  1108.                         rc != NO_MESSAGE)
  1109.                        WinAlarm(HWND_DESKTOP, WA_ERROR);
  1110.                  }
  1111.               }
  1112.               if (SHORT2FROMMP(mp1)==MSGVN_EXPORTCURRENT)
  1113.               {
  1114.                  /* Aktuelle Message exportieren, mp2 PDRAGTRANSFER */
  1115.                  PRENDERPAR pRenderPar=mp2;
  1116.                  ULONG ulOptions = 0x01 | 0x02;
  1117.  
  1118.                  ExportFile(client, pRenderPar->pchFileName, FALSE, &ulOptions);
  1119.                  free(pRenderPar->pchFileName);
  1120.  
  1121.                  SendMsg(WinWindowFromID(client, IDML_MAINEDIT),
  1122.                             MLM_EXPORTED, pRenderPar->pDragTransfer, NULL);
  1123.               }
  1124.               if (SHORT2FROMMP(mp1)==MLN_CURSORPOS)
  1125.               {
  1126.                  char pchTemp[20];
  1127.                  PWINDOWDATA pWindowData;
  1128.  
  1129.                  sprintf(pchTemp, "%d:%d", SHORT1FROMMP(mp2), SHORT2FROMMP(mp2));
  1130.                  pWindowData=(PWINDOWDATA)WinQueryWindowULong(client, QWL_USER);
  1131.                  WinSendDlgItemMsg(frame, FID_STATUSLINE, STLM_SETFIELDTEXT,
  1132.                                    MPFROMLONG(pWindowData->idCursorField),
  1133.                                    pchTemp);
  1134.               }
  1135.               break;
  1136.  
  1137.            default:
  1138.               break;
  1139.         }
  1140.         break;
  1141.  
  1142.      case SM_AREASCANNED:
  1143.         sprintf(chBuffer, pchFormatScanning, (char *) mp1);
  1144.         WinSetDlgItemText(frame, FID_STATUSLINE, chBuffer);
  1145.         break;
  1146.  
  1147.      case SM_SCANENDED:
  1148.         if (hwndAreaDlg)
  1149.            SendMsg(hwndAreaDlg, message, mp1, mp2);
  1150.         WinSetDlgItemText(frame, FID_STATUSLINE, "");
  1151.         break;
  1152.  
  1153.      case HM_QUERY_KEYS_HELP:
  1154.         return (MRESULT) PANEL_KEYS;
  1155.  
  1156.      case WM_CHAR:
  1157.         if ((SHORT1FROMMP(mp1) & KC_VIRTUALKEY) &&
  1158.             !(SHORT1FROMMP(mp1) & KC_KEYUP))
  1159.            if (SHORT2FROMMP(mp2) == VK_TAB ||
  1160.                SHORT2FROMMP(mp2) == VK_BACKTAB ||
  1161.                SHORT2FROMMP(mp2) == VK_NEWLINE ||
  1162.                SHORT2FROMMP(mp2) == VK_ENTER)
  1163.               return (MRESULT) ProcessKeys(client, SHORT2FROMMP(mp2));
  1164.  
  1165.         if (CurrentStatus == PROGSTATUS_EDITING)
  1166.         {
  1167.            bInsert=(BOOL)WinQuerySysValue(HWND_DESKTOP, SV_INSERTMODE);
  1168.            if (bInsert != pWindowData->bInsert)
  1169.            {
  1170.               if (bInsert)
  1171.                  WinSendDlgItemMsg(frame, FID_STATUSLINE, STLM_SETFIELDTEXT,
  1172.                                    MPFROMLONG(pWindowData->idKeybField),
  1173.                                    "INS");
  1174.               else
  1175.                  WinSendDlgItemMsg(frame, FID_STATUSLINE, STLM_SETFIELDTEXT,
  1176.                                    MPFROMLONG(pWindowData->idKeybField),
  1177.                                    "OVR");
  1178.            }
  1179.            pWindowData->bInsert=bInsert;
  1180.         }
  1181.         return (MRESULT) FALSE;
  1182.  
  1183.      case WM_ACTIVATE:
  1184.         if (mp1)
  1185.            WinAssociateHelpInstance(hwndhelp, frame);
  1186.         else
  1187.         {
  1188.            WinAssociateHelpInstance(hwndhelp, NULLHANDLE);
  1189.  
  1190.            if (CurrentStatus == PROGSTATUS_READING && MSG_IsApiOpen() &&
  1191.                !bIgnoreActivate)
  1192.            {
  1193.               MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1194.  
  1195.               strcpy(MessageID.pchAreaTag, CurrentArea);
  1196.               MessageID.ulMsgID=pWindowData->ulCurrentID;
  1197.               SendMsg(client, WORKM_READ, &MessageID, NULL);
  1198.            }
  1199.         }
  1200.         break;
  1201.  
  1202.      case FM_JUMPTOMESSAGE:
  1203.         if (CurrentStatus != PROGSTATUS_READING)
  1204.         {
  1205.            WinAlarm(HWND_DESKTOP, WA_WARNING);
  1206.            break;
  1207.         }
  1208.         if (zeiger=AM_FindArea(&arealiste, ((PMESSAGEID)mp1)->pchAreaTag))
  1209.         {
  1210.            ULONG ulMsgNum;
  1211.            PJUMPINFO pJumpInfo = (PJUMPINFO) mp2;
  1212.  
  1213.            /* Source-Window vermerken */
  1214.            pWindowData->ulSourceWindow = SOURCEWIN_BOOKMARKS;
  1215.  
  1216.            MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1217.  
  1218.            if (stricmp(CurrentArea, ((PMESSAGEID)mp1)->pchAreaTag))
  1219.            {
  1220.               MSGLISTPAR MsgListPar;
  1221.  
  1222.               /* Aktuelle Area schliessen */
  1223.               MSG_CloseArea(&arealiste, CurrentArea, TRUE, miscoptions.lastreadoffset, &driveremap);
  1224.  
  1225.               /* Neue Area oeffnen */
  1226.               SwitchToArea(((PMESSAGEID)mp1)->pchAreaTag);
  1227.               MsgListPar.msgnum=MSG_MsgnToUid(&arealiste, CurrentArea, QueryCurrent(&arealiste, CurrentArea));
  1228.               if (hwndThreadList)
  1229.                  SendMsg(hwndThreadList, TM_REREADTHREADS, &MsgListPar, NULL);
  1230.               if (hwndMsgList)
  1231.                  SendMsg(hwndMsgList, TM_REREADTHREADS, &MsgListPar, NULL);
  1232.            }
  1233.            /* gefundene Message lesen */
  1234.            ulMsgNum=MSG_UidToMsgn(&arealiste, CurrentArea, ((PMESSAGEID)mp1)->ulMsgID, TRUE);
  1235.            if (ulMsgNum == 0)
  1236.            {
  1237.               MessageBox(client, IDST_MSG_NOTTHERE, 0, IDD_NOTTHERE,
  1238.                          MB_OK | MB_ERROR);
  1239.               break;
  1240.            }
  1241.            zeiger->currentmessage=ulMsgNum;
  1242.            MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  1243.            pWindowData->ulCurrentID=((PMESSAGEID)mp1)->ulMsgID;
  1244.            WinEnableWindowUpdate(WinWindowFromID(client, IDML_MAINEDIT), FALSE);
  1245.            UpdateDisplay(FALSE, TRUE);
  1246.            if (pJumpInfo)
  1247.            {
  1248.               if ((pJumpInfo->ulWhere & FINDWHERE_TEXT) &&
  1249.                   ((pJumpInfo->ulHow & FINDHOW_METHOD_MASK) == FINDHOW_CASE ||
  1250.                    (pJumpInfo->ulHow & FINDHOW_METHOD_MASK) == FINDHOW_SENS))
  1251.                  WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_FINDTEXT, pJumpInfo->pchText,
  1252.                                    MPFROMLONG(((pJumpInfo->ulHow & FINDHOW_METHOD_MASK)==FINDHOW_CASE)?FALSE:TRUE));
  1253.            }
  1254.            WinEnableWindowUpdate(WinWindowFromID(client, IDML_MAINEDIT), TRUE);
  1255.         }
  1256.         else
  1257.            MessageBox(client, IDST_MSG_NOTTHERE, 0, IDD_NOTTHERE,
  1258.                       MB_OK | MB_ERROR);
  1259.         break;
  1260.  
  1261.      case TM_JUMPTOMESSAGE:
  1262.         if (CurrentStatus != PROGSTATUS_READING)
  1263.         {
  1264.            WinAlarm(HWND_DESKTOP, WA_WARNING);
  1265.            break;
  1266.         }
  1267.         if (pWindowData->pArea && pWindowData->pArea->areahandle)
  1268.         {
  1269.            int msgnum;
  1270.  
  1271.            /* Source-Window vermerken */
  1272.            if (mp2)
  1273.               pWindowData->ulSourceWindow = SOURCEWIN_MSGLIST;
  1274.            else
  1275.               pWindowData->ulSourceWindow = SOURCEWIN_THREAD;
  1276.  
  1277.            MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1278.            strcpy(MessageID.pchAreaTag, CurrentArea);
  1279.            MessageID.ulMsgID=pWindowData->ulCurrentID;
  1280.            SendMsg(client, WORKM_READ, &MessageID, NULL);
  1281.  
  1282.            msgnum=MSG_UidToMsgn(&arealiste, CurrentArea, (ULONG) mp1, TRUE);
  1283.            if (msgnum)
  1284.            {
  1285.               pWindowData->pArea->currentmessage=msgnum;
  1286.               MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  1287.               pWindowData->ulCurrentID= (ULONG) mp1;
  1288.               UpdateDisplay(FALSE, TRUE);
  1289.            }
  1290.         }
  1291.         break;
  1292.  
  1293.      case REQM_REQUEST:
  1294.         pRequestPar=(REQUESTPAR*)mp1;
  1295.         if (pRequestPar->pReqList)
  1296.         {
  1297.            int rc;
  1298.  
  1299.            if (pRequestPar->bDirect)
  1300.               rc=MSG_RequestDirect(pRequestPar->pchReqAddr, userdaten.address[0],
  1301.                                    pRequestPar->pReqList, outbound, &driveremap,
  1302.                                    pRequestPar->ulAttrib);
  1303.            else
  1304.               rc=MSG_RequestFiles(&arealiste, pRequestPar->pchDestArea,
  1305.                                   pRequestPar->pchReqAddr,
  1306.                                   pRequestPar->pchReqName,
  1307.                                   pRequestPar->pReqList,
  1308.                                   pRequestPar->ulAttrib,
  1309.                                   CurrentName, CurrentAddress,
  1310.                                   &userdaten, &generaloptions,
  1311.                                   miscoptions.lastreadoffset,
  1312.                                   &driveremap, &templatelist, SendAddMessage);
  1313.            if (rc)
  1314.               WinAlarm(HWND_DESKTOP, WA_ERROR);
  1315.            else
  1316.            {
  1317.               Notify(fenster, IDST_NOT_REQUESTED);
  1318.  
  1319.               zeiger=AM_FindArea(&arealiste, pRequestPar->pchDestArea);
  1320.               if (zeiger)
  1321.                  zeiger->mailentered = TRUE;
  1322.               MailEntered[zeiger->areadata.areatype] = TRUE;
  1323.            }
  1324.         }
  1325.         break;
  1326.  
  1327.      case REQM_CLOSE:
  1328.         pRequestPar=(REQUESTPAR*)mp1;
  1329.         ulResult=(ULONG) mp2;
  1330.         if (ulResult==DID_OK)
  1331.         {
  1332.            if (stricmp(requestoptions.pchDestArea, pRequestPar->pchDestArea))
  1333.            {
  1334.               strcpy(requestoptions.pchDestArea, pRequestPar->pchDestArea);
  1335.               requestoptions.bDirty=TRUE;
  1336.            }
  1337.            if (requestoptions.bDirectReq != pRequestPar->bDirect)
  1338.            {
  1339.               requestoptions.bDirectReq = pRequestPar->bDirect;
  1340.               requestoptions.bDirty=TRUE;
  1341.            }
  1342.            if (requestoptions.ulAttrib != pRequestPar->ulAttrib)
  1343.            {
  1344.               requestoptions.ulAttrib = pRequestPar->ulAttrib;
  1345.               requestoptions.bDirty=TRUE;
  1346.            }
  1347.         }
  1348.         SendMsg(client, WORKM_ENABLEVIEWS, NULL, NULL);
  1349.         FreeRequestList(pRequestPar->pReqList);
  1350.         free(pRequestPar);
  1351.         WinDestroyWindow(hwndRequester);
  1352.         hwndRequester=NULLHANDLE;
  1353.         break;
  1354.  
  1355.      case WORKM_ERROR:
  1356.      case WORKM_DELETED:
  1357.      case WORKM_MOVED:
  1358.      case WORKM_COPIED:
  1359.      case WORKM_PRINTED:
  1360.      case WORKM_EXPORTED:
  1361.      case WORKM_ADDED:
  1362.      case WORKM_CHANGED:
  1363.      case WORKM_READ:
  1364.      case WORKM_END:
  1365.      case WORKM_DISABLEVIEWS:
  1366.      case WORKM_ENABLEVIEWS:
  1367.      case WORKM_REREAD:
  1368.      case WORKM_SHOWMSG:
  1369.      case WORKM_AREADEFCHANGED:
  1370.      case WORKM_AREASCANNED:
  1371.      case WORKM_MARKEND:
  1372.      case WORKM_STARTWORKAREA:
  1373.      case WORKM_PROGRESS:
  1374.      case WORKM_STARTFIND:
  1375.      case WORKM_FINDAREA:
  1376.      case WORKM_FINDPROGRESS:
  1377.      case WORKM_FINDAREAEND:
  1378.      case WORKM_STOPFIND:
  1379.      case WORKM_MSGMARKED:
  1380.      case WORKM_MSGUNMARKED:
  1381.      case WORKM_TRACKMSG:
  1382.      case WORKM_SWITCHACCELS:
  1383.         return (ProcessWorkMessages(client, message, mp1, mp2));
  1384.  
  1385.      case REXXM_STOPSCRIPT:
  1386.      case REXXM_ERROR:
  1387.         if (hwndMonitor)
  1388.            SendMsg(hwndMonitor, message, mp1, mp2);
  1389.         else
  1390.            if (message == REXXM_ERROR)
  1391.               DisplayRexxError(client, (PCHAR) mp1, (PCHAR) mp2);
  1392.  
  1393.         switch (pWindowData->ulCurrentHook)
  1394.         {
  1395.            case CURRENTHOOK_NONE:
  1396.               break;
  1397.  
  1398.            case CURRENTHOOK_PRESAVE:
  1399.               pWindowData->ulCurrentHook = CURRENTHOOK_NONE;
  1400.               bNoHook=TRUE;
  1401.               ProcessCommands(client, IDB_OK);
  1402.               bNoHook=FALSE;
  1403.               break;
  1404.  
  1405.            case CURRENTHOOK_EXIT:
  1406.               pWindowData->ulCurrentHook = CURRENTHOOK_NONE;
  1407.               CurrentStatus = PROGSTATUS_READING;
  1408.               bNoHook=TRUE;
  1409.               tidRexxExec=0;
  1410.               SendMsg(client, WM_CLOSE, NULL, NULL);
  1411.               bNoHook=FALSE;
  1412.               break;
  1413.         }
  1414.         tidRexxExec=0;
  1415.         SendMsg(client, WORKM_ENABLEVIEWS, NULL, NULL);
  1416.         break;
  1417.  
  1418.      case REXXM_OUTLINE:
  1419.      case REXXM_STARTSCRIPT:
  1420.         if (hwndMonitor)
  1421.            SendMsg(hwndMonitor, message, mp1, mp2);
  1422.         break;
  1423.  
  1424.      /* Alle anderen Messages */
  1425.      default:
  1426.         break;
  1427.    }
  1428.    return WinDefWindowProc(fenster,message,mp1,mp2);
  1429. }
  1430.  
  1431. static void ProcessCommands(HWND client, USHORT CommandID)
  1432. {
  1433.    CURRNAMEPAR CurrNamePar;
  1434.    AREALISTPAR AreaListPar;
  1435.    CCSELECTPAR CCSelectPar;
  1436.    REQUESTPAR *pRequestPar;
  1437.    PWINDOWDATA pWindowData;
  1438.    MESSAGEID MessageID;
  1439.    AREADEFLIST *zeiger=NULL;
  1440.    REPLYLISTPAR ReplyListPar;
  1441.    MSGLISTPAR   MsgListPar;
  1442.    ATTRIBPAR AttribPar;
  1443.    REPLYPAR ReplyPar;
  1444.    int msgnum;
  1445.  
  1446.  
  1447.    pWindowData=(PWINDOWDATA) WinQueryWindowULong(client, QWL_USER);
  1448.  
  1449.    switch(CommandID)
  1450.    {
  1451.       case IDB_CHANGEATTR:
  1452.       case IDA_ATTRIB:
  1453.          AttribPar.cb=sizeof(ATTRIBPAR);
  1454.          MSG_QueryAttribCaps(&arealiste, NewMessage?NewArea:CurrentArea, &AttribPar.ulAttribMask);
  1455.          AttribPar.ulAttrib=CurrentHeader.ulAttrib;
  1456.          AttribPar.bKeepRead = TRUE;
  1457.          if (WinDlgBox(HWND_DESKTOP,
  1458.                        client,
  1459.                        AttribProc,
  1460.                        hmodLang,
  1461.                        IDD_ATTRIB,
  1462.                        &AttribPar)==DID_OK)
  1463.          {
  1464.             /* Attribute uebernehmen */
  1465.             CurrentHeader.ulAttrib=AttribPar.ulAttrib;
  1466.  
  1467.             HandleAttachAttrib(client);
  1468.          }
  1469.          break;
  1470.  
  1471.       case IDB_FIND:
  1472.       case IDM_MSGFIND:
  1473.       case IDA_FIND:
  1474.          if (CurrentStatus==PROGSTATUS_READING)
  1475.          {
  1476.             hwndFindDlg=WinLoadDlg(HWND_DESKTOP,
  1477.                                    client,
  1478.                                    FindProc,
  1479.                                    hmodLang,
  1480.                                    IDD_FINDTEXT,
  1481.                                    NULL);
  1482.             WinProcessDlg(hwndFindDlg);
  1483.             WinDestroyWindow(hwndFindDlg);
  1484.             hwndFindDlg=NULLHANDLE;
  1485.          }
  1486.          break;
  1487.  
  1488.       case IDB_CUT:
  1489.       case IDM_EDITCUT:
  1490.          EditMenuCommands(client, IDM_EDITCUT);
  1491.          break;
  1492.  
  1493.       case IDB_COPY:
  1494.       case IDM_EDITCOPY:
  1495.          EditMenuCommands(client, IDM_EDITCOPY);
  1496.          break;
  1497.  
  1498.       case IDB_PASTE:
  1499.       case IDM_EDITPASTE:
  1500.          EditMenuCommands(client, IDM_EDITPASTE);
  1501.          break;
  1502.  
  1503.       case IDM_EDITUNDO:
  1504.       case IDM_EDITCLEAR:
  1505.       case IDM_EDITDELLINE:
  1506.          EditMenuCommands(client, CommandID);
  1507.          break;
  1508.  
  1509.       case IDB_AREA:
  1510.       case IDA_AREA:
  1511.          if (CurrentStatus==PROGSTATUS_READING)
  1512.          {
  1513.             MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1514.             strcpy(MessageID.pchAreaTag, CurrentArea);
  1515.             MessageID.ulMsgID=pWindowData->ulCurrentID;
  1516.             SendMsg(client, WORKM_READ, &MessageID, NULL);
  1517.  
  1518.             if (!hwndAreaDlg)
  1519.             {
  1520.                AreaListPar.cb=sizeof(AREALISTPAR);
  1521.                AreaListPar.pchString=strdup(CurrentArea);
  1522.                AreaListPar.idTitle = 0;
  1523.                AreaListPar.ulIncludeTypes = INCLUDE_ALL;
  1524.                AreaListPar.bExtendedSel = TRUE;
  1525.                AreaListPar.bChange      = TRUE;
  1526.  
  1527.                hwndAreaDlg=WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP,
  1528.                                       AreaListProc, hmodLang,
  1529.                                       IDD_AREALIST, &AreaListPar);
  1530.                WinShowWindow(hwndAreaDlg, TRUE);
  1531.             }
  1532.             else
  1533.             {
  1534.                SWP swp;
  1535.  
  1536.                SetFocusControl(hwndAreaDlg, IDD_AREALIST+1);
  1537.                WinQueryWindowPos(hwndAreaDlg, &swp);
  1538.                if (swp.fl & SWP_MINIMIZE)
  1539.                   WinSetWindowPos(hwndAreaDlg,
  1540.                                   NULLHANDLE,
  1541.                                   0, 0, 0, 0,
  1542.                                   SWP_RESTORE);
  1543.             }
  1544.          }
  1545.          break;
  1546.  
  1547.       case IDB_MSGLIST:
  1548.       case IDA_MSGLIST:
  1549.          if (CurrentStatus==PROGSTATUS_READING &&
  1550.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  1551.          {
  1552.             if (!hwndMsgList)
  1553.             {
  1554.                if (pWindowData->pArea)
  1555.                {
  1556.                   MsgListPar.cb=sizeof(MSGLISTPAR);
  1557.                   MsgListPar.msgnum=pWindowData->pArea->currentmessage;
  1558.  
  1559.                   hwndMsgList= WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP,
  1560.                                           MsgListProc, hmodLang,
  1561.                                           IDD_MSGLIST, &MsgListPar);
  1562.                   SetFocusControl(hwndMsgList, IDD_MSGLIST+1);
  1563.                }
  1564.             }
  1565.             else
  1566.             {
  1567.                SWP swp;
  1568.  
  1569.                SetFocusControl(hwndMsgList, IDD_MSGLIST+1);
  1570.                WinQueryWindowPos(hwndMsgList, &swp);
  1571.                if (swp.fl & SWP_MINIMIZE)
  1572.                   WinSetWindowPos(hwndMsgList,
  1573.                                   NULLHANDLE,
  1574.                                   0, 0, 0, 0,
  1575.                                   SWP_RESTORE);
  1576.             }
  1577.          }
  1578.          break;
  1579.  
  1580.       case IDB_REPLY:
  1581.       case IDM_MSGREPLY:
  1582.          ReplyPar.cb=sizeof(REPLYPAR);
  1583.          if (MSG_FindKludge(&CurrentMessage, KLUDGE_AREA, NULL))
  1584.             ReplyPar.diffarea = TRUE;
  1585.          else
  1586.             ReplyPar.diffarea = FALSE;
  1587.          if (MSG_FindKludge(&CurrentMessage, KLUDGE_FWDFROM, NULL))
  1588.             ReplyPar.isfwd = TRUE;
  1589.          else
  1590.             ReplyPar.isfwd = FALSE;
  1591.          if (WinDlgBox(HWND_DESKTOP, client,
  1592.                        ReplyProc, hmodLang, IDD_REPLY,
  1593.                        &ReplyPar)!=DID_OK)
  1594.             break;
  1595.  
  1596.          QuoteCurrentMessage(pWindowData, ReplyPar.diffarea, ReplyPar.replydest, ReplyPar.quoteoptions);
  1597.          break;
  1598.  
  1599.       case IDB_NEXTMSG:
  1600.       case IDA_NEXTMSG:
  1601.          if (CurrentStatus==PROGSTATUS_READING)
  1602.          {
  1603.             MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1604.             strcpy(MessageID.pchAreaTag, CurrentArea);
  1605.             MessageID.ulMsgID=pWindowData->ulCurrentID;
  1606.             SendMsg(client, WORKM_READ, &MessageID, NULL);
  1607.  
  1608.             if (!pWindowData->pArea->maxmessages || (pWindowData->pArea->maxmessages && (pWindowData->pArea->currentmessage == pWindowData->pArea->maxmessages)))
  1609.             {
  1610.                ShowFleetWindow(IDM_WINAREAS);
  1611.             }
  1612.             else
  1613.             {
  1614.                if (MSG_ReadNext(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea))
  1615.                   WinAlarm(HWND_DESKTOP, WA_WARNING);
  1616.                pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  1617.                UpdateDisplay(FALSE, TRUE);
  1618.             }
  1619.          }
  1620.          break;
  1621.  
  1622.       case IDB_PREVMSG:
  1623.       case IDA_PREVMSG:
  1624.          if (CurrentStatus==PROGSTATUS_READING)
  1625.          {
  1626.             MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1627.             strcpy(MessageID.pchAreaTag, CurrentArea);
  1628.             MessageID.ulMsgID=pWindowData->ulCurrentID;
  1629.             SendMsg(client, WORKM_READ, &MessageID, NULL);
  1630.  
  1631.             if (MSG_ReadPrev(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea))
  1632.                WinAlarm(HWND_DESKTOP, WA_WARNING);
  1633.             pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  1634.             UpdateDisplay(FALSE, TRUE);
  1635.          }
  1636.          break;
  1637.  
  1638.       case IDB_LASTMSG:
  1639.       case IDA_LASTMSG:
  1640.          if (CurrentStatus==PROGSTATUS_READING)
  1641.          {
  1642.             MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1643.             strcpy(MessageID.pchAreaTag, CurrentArea);
  1644.             MessageID.ulMsgID=pWindowData->ulCurrentID;
  1645.             SendMsg(client, WORKM_READ, &MessageID, NULL);
  1646.  
  1647.             if (pWindowData->pArea &&  (pWindowData->pArea->maxmessages > 0))
  1648.             {
  1649.                pWindowData->pArea->currentmessage=pWindowData->pArea->maxmessages;
  1650.                if(MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea))
  1651.                   WinAlarm(HWND_DESKTOP, WA_WARNING);
  1652.                pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  1653.                UpdateDisplay(FALSE, TRUE);
  1654.             }
  1655.          }
  1656.          break;
  1657.  
  1658.       case IDB_FIRSTMSG:
  1659.       case IDA_FIRSTMSG:
  1660.          if (CurrentStatus==PROGSTATUS_READING)
  1661.          {
  1662.             MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1663.             strcpy(MessageID.pchAreaTag, CurrentArea);
  1664.             MessageID.ulMsgID=pWindowData->ulCurrentID;
  1665.             SendMsg(client, WORKM_READ, &MessageID, NULL);
  1666.  
  1667.             if (pWindowData->pArea && (pWindowData->pArea->maxmessages > 0))
  1668.             {
  1669.                pWindowData->pArea->currentmessage=1;
  1670.                if (MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea))
  1671.                   WinAlarm(HWND_DESKTOP, WA_WARNING);
  1672.                pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  1673.                UpdateDisplay(FALSE, TRUE);
  1674.             }
  1675.          }
  1676.          break;
  1677.  
  1678.       case IDB_PREVREPLY:
  1679.       case IDA_PREVREPLY:
  1680.          if (CurrentStatus==PROGSTATUS_READING)
  1681.          {
  1682.             MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1683.             strcpy(MessageID.pchAreaTag, CurrentArea);
  1684.             MessageID.ulMsgID=pWindowData->ulCurrentID;
  1685.             SendMsg(client, WORKM_READ, &MessageID, NULL);
  1686.  
  1687.             if (pWindowData->pArea)
  1688.             {
  1689.                msgnum=MSG_UidToMsgn(&arealiste, CurrentArea, CurrentHeader.ulReplyTo, TRUE);
  1690.                if (msgnum)
  1691.                {
  1692.                   pWindowData->pArea->currentmessage=msgnum;
  1693.                   MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  1694.                   pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  1695.                   UpdateDisplay(FALSE, TRUE);
  1696.                }
  1697.                else
  1698.                   if (hwndThreadList)
  1699.                      SetFocusControl(hwndThreadList, IDD_THREADLIST+1);
  1700.                   else
  1701.                      WinAlarm(HWND_DESKTOP, WA_WARNING);
  1702.             }
  1703.             else
  1704.                WinAlarm(HWND_DESKTOP, WA_WARNING);
  1705.          }
  1706.          break;
  1707.  
  1708.       case IDB_NEXTREPLY:
  1709.       case IDA_NEXTREPLY:
  1710.          if (CurrentStatus==PROGSTATUS_READING)
  1711.          {
  1712.             MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1713.             strcpy(MessageID.pchAreaTag, CurrentArea);
  1714.             MessageID.ulMsgID=pWindowData->ulCurrentID;
  1715.             SendMsg(client, WORKM_READ, &MessageID, NULL);
  1716.  
  1717.             if (CurrentHeader.ulReplies[1]==0)  /* nur ein Reply da */
  1718.                ReplyListPar.Selection=CurrentHeader.ulReplies[0];
  1719.             else
  1720.             {
  1721.                ReplyListPar.cb=sizeof(REPLYLISTPAR);
  1722.                ReplyListPar.pHeader=&CurrentHeader;
  1723.                if (WinDlgBox(HWND_DESKTOP,
  1724.                          client,
  1725.                          ReplyListProc,
  1726.                          hmodLang,
  1727.                          IDD_REPLYLIST,
  1728.                          &ReplyListPar)!=DID_OK)
  1729.                   break;
  1730.             }
  1731.             if (pWindowData->pArea)
  1732.             {
  1733.                msgnum=MSG_UidToMsgn(&arealiste, CurrentArea, ReplyListPar.Selection, TRUE);
  1734.                if (msgnum)
  1735.                {
  1736.                   pWindowData->pArea->currentmessage=msgnum;
  1737.                   MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  1738.                   pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  1739.                   UpdateDisplay(FALSE, TRUE);
  1740.                }
  1741.                else
  1742.                   if (hwndThreadList)
  1743.                      SetFocusControl(hwndThreadList, IDD_THREADLIST+1);
  1744.                   else
  1745.                      WinAlarm(HWND_DESKTOP, WA_WARNING);
  1746.             }
  1747.             else
  1748.                WinAlarm(HWND_DESKTOP, WA_WARNING);
  1749.          }
  1750.          break;
  1751.  
  1752.       case IDB_SHOWKLUDGES:
  1753.       case IDA_KLUDGES:
  1754.          if ((CurrentStatus == PROGSTATUS_READING ||
  1755.               CurrentStatus == PROGSTATUS_EDITING) &&
  1756.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  1757.          {
  1758.             if (!hwndKludge)
  1759.             {
  1760.                hwndKludge=WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP,
  1761.                                      KludgesProc,
  1762.                                      hmodLang,
  1763.                                      IDD_KLUDGEINFO,
  1764.                                      NULL);
  1765.                SendMsg(hwndKludge, KM_SHOWKLUDGES,
  1766.                           MPFROMP(&CurrentMessage), NULL);
  1767.                WinShowWindow(hwndKludge, TRUE);
  1768.             }
  1769.             else
  1770.             {
  1771.                SWP swp;
  1772.  
  1773.                SetFocus(hwndKludge);
  1774.                WinQueryWindowPos(hwndKludge, &swp);
  1775.                if (swp.fl & SWP_MINIMIZE)
  1776.                   WinSetWindowPos(hwndKludge,
  1777.                                   NULLHANDLE,
  1778.                                   0, 0, 0, 0,
  1779.                                   SWP_RESTORE);
  1780.             }
  1781.          }
  1782.          break;
  1783.  
  1784.       case IDB_DELMSG:
  1785.       case IDM_MSGDELETE:
  1786.       case IDA_DELMSG:
  1787.          if (CurrentStatus==PROGSTATUS_READING &&
  1788.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  1789.          {
  1790.             int rc;
  1791.  
  1792.             if (generaloptions.safety & SAFETY_DELMSG)
  1793.             {
  1794.                if (MessageBox(client, IDST_MSG_DELETE, IDST_TITLE_DELETE,
  1795.                               IDD_DELETE, MB_YESNO | MB_ICONEXCLAMATION)!=MBID_YES)
  1796.                   break;
  1797.             }
  1798.             /* Momentane Message loeschen */
  1799.             rc=MSG_KillMessage(&arealiste, CurrentArea, 0, &driveremap, SendKillMessage);
  1800.             if (rc != OK &&
  1801.                 rc != NO_MESSAGE)
  1802.                WinAlarm(HWND_DESKTOP, WA_ERROR);
  1803.          }
  1804.          break;
  1805.  
  1806.       case IDB_EDITMSG:
  1807.       case IDM_MSGCHANGE:
  1808.       case IDA_CHANGEMSG:
  1809.          if (CurrentStatus==PROGSTATUS_READING &&
  1810.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  1811.          {
  1812.             if ((generaloptions.safety & SAFETY_EDITSENT) &&
  1813.                 ((CurrentHeader.ulAttrib & ATTRIB_SENT) || !(CurrentHeader.ulAttrib & ATTRIB_LOCAL)))
  1814.             {
  1815.                if (MessageBox(client, IDST_MSG_BEENSENT, IDST_TITLE_BEENSENT,
  1816.                               IDD_BEENSENT, MB_YESNO | MB_ICONQUESTION)!=MBID_YES)
  1817.                   break;
  1818.             }
  1819.             if (CurrentHeader.ulAttrib & ATTRIB_LOCAL)
  1820.                bOldMsgLocal=TRUE;
  1821.             else
  1822.                bOldMsgLocal=FALSE;
  1823.             NewMessage=FALSE;
  1824.             SendMsg(client, WORKM_ENABLEVIEWS, NULL, NULL);
  1825.             strcpy(NewArea, CurrentArea);
  1826.             SwitchEditor(client, NewArea, TRUE);
  1827.             CurrentStatus = PROGSTATUS_EDITING;
  1828.             DisplayMsgText(client, &CurrentMessage);
  1829.             StatusChanged(client, CurrentStatus);
  1830.             SetFocusControl(client, IDML_MAINEDIT);
  1831.          }
  1832.          break;
  1833.  
  1834.       case IDB_NEWMSG:
  1835.       case IDM_MSGNEW:
  1836.       case IDA_ENTER:
  1837.          if (CurrentStatus == PROGSTATUS_READING &&
  1838.              CurrentArea[0] )
  1839.          {
  1840.             NewMessage=TRUE;
  1841.             SendMsg(client, WORKM_DISABLEVIEWS, NULL, NULL);
  1842.             strcpy(NewArea, CurrentArea);
  1843.             MSG_NewMessage(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea,
  1844.                            CurrentName, CurrentAddress, &iptInitialPos);
  1845.             bTemplateProcessed=FALSE;
  1846.             ulTemplateType=TPLTYPE_NEW;
  1847.             iptInitialPos2=0;
  1848.  
  1849.             SwitchEditor(client, NewArea, TRUE);
  1850.             CurrentStatus = PROGSTATUS_EDITING;
  1851.             UpdateDisplay(FALSE, FALSE);
  1852.             StatusChanged(client, CurrentStatus);
  1853.             SetFocusControl(client, IDE_TONAME);
  1854.          }
  1855.          break;
  1856.  
  1857.       case IDB_MSGTREE:
  1858.       case IDA_THREADLIST:
  1859.          if (CurrentStatus==PROGSTATUS_READING &&
  1860.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  1861.          {
  1862.             MsgListPar.cb=sizeof(MSGLISTPAR);
  1863.             MsgListPar.msgnum=MSG_MsgnToUid(&arealiste, CurrentArea, QueryCurrent(&arealiste, CurrentArea));
  1864.  
  1865.             if (hwndThreadList)
  1866.             {
  1867.                SWP swp;
  1868.  
  1869.                SetFocusControl(hwndThreadList, IDD_THREADLIST+1);
  1870.                WinQueryWindowPos(hwndThreadList, &swp);
  1871.                if (swp.fl & SWP_MINIMIZE)
  1872.                   WinSetWindowPos(hwndThreadList,
  1873.                                   NULLHANDLE,
  1874.                                   0, 0, 0, 0,
  1875.                                   SWP_RESTORE);
  1876.             }
  1877.             else
  1878.             {
  1879.                MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  1880.                hwndThreadList=WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP,
  1881.                                          ThreadListProc,
  1882.                                          hmodLang, IDD_THREADLIST,
  1883.                                          &MsgListPar);
  1884.                WinShowWindow(hwndThreadList, TRUE);
  1885.             }
  1886.          }
  1887.          break;
  1888.  
  1889.       case IDB_IMPORT:
  1890.       case IDM_FILEIMPORT:
  1891.       case IDA_IMPORT:
  1892.          if (CurrentStatus==PROGSTATUS_EDITING)
  1893.             switch(ImportFile(client, pathnames.lastimport,
  1894.                    !(pWindowData->pArea->areadata.ulAreaOpt & AREAOPT_HIGHASCII), TRUE))
  1895.             {
  1896.                /* Lesefehler */
  1897.                case 1:
  1898.                   MessageBox(client, IDST_MSG_ERRORLOAD, 0, IDD_ERRORLOAD,
  1899.                              MB_OK | MB_ERROR);
  1900.                   break;
  1901.  
  1902.                /* Falscher Filename usw. */
  1903.                case 2:
  1904.                   MessageBox(client, IDST_MSG_INVALIDFILE, 0, IDD_INVALIDFILE,
  1905.                              MB_OK | MB_ERROR);
  1906.                   break;
  1907.  
  1908.                /* File leer */
  1909.                case 3:
  1910.                   MessageBox(client, IDST_MSG_EMPTYFILE, 0, IDD_EMPTYFILE,
  1911.                              MB_OK | MB_ERROR);
  1912.                   break;
  1913.  
  1914.                default:
  1915.                   break;
  1916.             }
  1917.          break;
  1918.  
  1919.       case IDB_EXPORT:
  1920.       case IDM_FILEEXPORT:
  1921.       case IDA_EXPORT:
  1922.          if (CurrentStatus==PROGSTATUS_READING &&
  1923.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  1924.          {
  1925.             SendMsg(client, WORKM_DISABLEVIEWS, NULL, NULL);
  1926.             switch(ExportFile(client, pathnames.lastexport, TRUE, &ulExportOptions))
  1927.             {
  1928.                /* Alles OK */
  1929.                case 0:
  1930.                   Notify(client, IDST_NOT_EXPORTED);
  1931.                   break;
  1932.  
  1933.                /* Fehler beim Schreiben */
  1934.                case 1:
  1935.                   MessageBox(client, IDST_MSG_ERRORSAVE, 0, IDD_ERRORSAVE,
  1936.                              MB_OK | MB_ERROR);
  1937.                   break;
  1938.  
  1939.                /* Falscher Filename */
  1940.                case 2:
  1941.                   MessageBox(client, IDST_MSG_INVALIDFILENAME, 0, IDD_INVALIDFILENAME,
  1942.                              MB_OK | MB_ERROR);
  1943.                   break;
  1944.  
  1945.                /* Abbruch */
  1946.                case 3:
  1947.                   break;
  1948.  
  1949.                default:
  1950.                   break;
  1951.             }
  1952.             SendMsg(client, WORKM_ENABLEVIEWS, NULL, NULL);
  1953.          }
  1954.          break;
  1955.  
  1956.       case IDB_PRINTMSG:
  1957.       case IDM_FILEPRINT:
  1958.       case IDA_PRINT:
  1959.          if (CurrentStatus==PROGSTATUS_READING &&
  1960.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  1961.          {
  1962.             PWORKDATA pWorkData;
  1963.  
  1964.             pWorkData=malloc(sizeof(WORKDATA));
  1965.  
  1966.             pWorkData->next=NULL;
  1967.             pWorkData->MsgIDArray=malloc(sizeof(ULONG));
  1968.             pWorkData->MsgIDArray[0] = pWindowData->ulCurrentID;
  1969.             pWorkData->ulArraySize = 1;
  1970.             pWorkData->flWorkToDo=WORK_PRINT;
  1971.             pWorkData->pPrintDest=NULL;
  1972.             strcpy(pWorkData->pchSrcArea, CurrentArea);
  1973.             bDoingWork=TRUE;
  1974.             _beginthread(WorkerThread, NULL, 32768, pWorkData);
  1975.             Notify(client, IDST_NOT_PRINTED);
  1976.          }
  1977.          break;
  1978.  
  1979.       case IDB_CANCEL:
  1980.       case IDA_CANCEL:
  1981.          if (CurrentStatus == PROGSTATUS_EDITING)
  1982.          {
  1983.             if (generaloptions.safety & SAFETY_DISCARD)
  1984.             {
  1985.                if (MessageBox(client, IDST_MSG_CANCEL, IDST_TITLE_CANCEL,
  1986.                               IDD_DISCARD, MB_YESNO | MB_ICONQUESTION)!=MBID_YES)
  1987.                   break;
  1988.             }
  1989.             NewMessage=FALSE;
  1990.             SwitchEditor(client, CurrentArea, FALSE);
  1991.             CurrentStatus = PROGSTATUS_READING;
  1992.             StatusChanged(client, CurrentStatus);
  1993.             MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  1994.             UpdateDisplay(TRUE, TRUE);
  1995.             if (pchXPostList)
  1996.             {
  1997.                free(pchXPostList);
  1998.                pchXPostList=NULL;
  1999.             }
  2000.             if (ulCCSelected)
  2001.             {
  2002.                ulCCSelected=0;
  2003.                WinSendDlgItemMsg(client, IDE_TONAME, EM_SETREADONLY, (MPARAM) FALSE, NULL);
  2004.                WinSendDlgItemMsg(client, IDE_TOADDRESS, EM_SETREADONLY, (MPARAM) FALSE, NULL);
  2005.             }
  2006.             if (pQuickCCList)
  2007.             {
  2008.                while(pQuickCCList->pEntries)
  2009.                   DeleteCCEntry(NULL, pQuickCCList, pQuickCCList->pEntries);
  2010.                free(pQuickCCList->pchListName);
  2011.                free(pQuickCCList);
  2012.                pQuickCCList=NULL;
  2013.             }
  2014.             SendMsg(client, WORKM_ENABLEVIEWS, NULL, NULL);
  2015.          }
  2016.          else
  2017.             if (CurrentStatus == PROGSTATUS_READING)
  2018.             {
  2019.                bStopWork=TRUE;
  2020.                StopAreaScan = TRUE;
  2021.             }
  2022.          break;
  2023.  
  2024.       case IDB_OK:
  2025.       case IDA_SAVE:
  2026.          if (pWindowData->ulCurrentHook != CURRENTHOOK_NONE)
  2027.             break;
  2028.          if (!bNoHook && rexxhooks.ulPreSaveID && !StartRexxScript(rexxhooks.ulPreSaveID, NULL))
  2029.          {
  2030.             pWindowData->ulCurrentHook = CURRENTHOOK_PRESAVE;
  2031.             break;
  2032.          }
  2033.  
  2034.          if (NewMessage)
  2035.          {
  2036.             if (pchXPostList)
  2037.             {
  2038.                if (!SaveCrosspostMessage(client, &CurrentMessage, &CurrentHeader,
  2039.                                          NewArea, &pchXPostList))
  2040.                {
  2041.                   SwitchEditor(client, CurrentArea, FALSE);
  2042.                   CurrentStatus = PROGSTATUS_READING;
  2043.                   StatusChanged(client, CurrentStatus);
  2044.                   MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  2045.                   NewMessage=FALSE;
  2046.                   UpdateDisplay(TRUE, TRUE);
  2047.                   free(pchXPostList);
  2048.                   pchXPostList=NULL;
  2049.                }
  2050.                else
  2051.                   break;
  2052.             }
  2053.             else
  2054.             {
  2055.                if (ulCCSelected || pQuickCCList)
  2056.                {
  2057.                   PCCLIST pList;
  2058.  
  2059.                   if (ulCCSelected)
  2060.                      pList = QueryCCList(&ccanchor, ulCCSelected);
  2061.                   else
  2062.                      pList = pQuickCCList;
  2063.  
  2064.                   if (!pList)
  2065.                   {
  2066.                      MessageBox(client, IDST_MSG_NOCCLIST, 0, IDD_NOCCLIST,
  2067.                                 MB_OK | MB_ERROR);
  2068.                      ulCCSelected=0;
  2069.                      WinSendDlgItemMsg(client, IDE_TONAME, EM_SETREADONLY, (MPARAM) FALSE, NULL);
  2070.                      WinSendDlgItemMsg(client, IDE_TOADDRESS, EM_SETREADONLY, (MPARAM) FALSE, NULL);
  2071.                      WinSetDlgItemText(client, IDE_TOADDRESS, SaveToAddress);
  2072.                      WinSetDlgItemText(client, IDE_TONAME, SaveToName);
  2073.                      break;
  2074.                   }
  2075.  
  2076.                   if (!pList->pEntries)
  2077.                   {
  2078.                      MessageBox(client, IDST_MSG_NOCCENTRIES, 0, IDD_NOCCENTRIES,
  2079.                                 MB_OK | MB_ERROR);
  2080.                      break;
  2081.                   }
  2082.  
  2083.                   if (!SaveCCMessage(client, &CurrentMessage, &CurrentHeader,
  2084.                                      NewArea, pList))
  2085.                   {
  2086.                      SwitchEditor(client, CurrentArea, FALSE);
  2087.                      ulCCSelected=0;
  2088.                      if (pQuickCCList)
  2089.                      {
  2090.                         while(pQuickCCList->pEntries)
  2091.                            DeleteCCEntry(NULL, pQuickCCList, pQuickCCList->pEntries);
  2092.                         free(pQuickCCList->pchListName);
  2093.                         free(pQuickCCList);
  2094.                         pQuickCCList=NULL;
  2095.                      }
  2096.                      CurrentStatus = PROGSTATUS_READING;
  2097.                      StatusChanged(client, CurrentStatus);
  2098.                      MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  2099.                      NewMessage=FALSE;
  2100.                      UpdateDisplay(TRUE, TRUE);
  2101.                   }
  2102.                   else
  2103.                      break;
  2104.                }
  2105.                else
  2106.                {
  2107.                   if (!SaveMessage(client, &CurrentMessage, &CurrentHeader, NewArea))
  2108.                   {
  2109.                      /* Switch back to reading mode */
  2110.                      SwitchEditor(client, CurrentArea, FALSE);
  2111.                      CurrentStatus = PROGSTATUS_READING;
  2112.                      StatusChanged(client, CurrentStatus);
  2113.                      MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  2114.                      NewMessage=FALSE;
  2115.                      UpdateDisplay(TRUE, TRUE);
  2116.                   }
  2117.                   else
  2118.                      break;
  2119.                }
  2120.             }
  2121.  
  2122.             pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  2123.             SendMsg(client, WORKM_ENABLEVIEWS, NULL, NULL);
  2124.          }
  2125.          else
  2126.          {
  2127.             int rc;
  2128.  
  2129.             if (CurrentHeader.ulAttrib & (ATTRIB_SENT | ATTRIB_SCANNED))
  2130.             {
  2131.                if (MessageBox(client, IDST_MSG_RESEND, IDST_TITLE_RESEND,
  2132.                               IDD_RESEND, MB_YESNO | MB_ICONQUESTION)==MBID_YES)
  2133.                   CurrentHeader.ulAttrib &= ~(ATTRIB_SENT | ATTRIB_SCANNED);
  2134.             }
  2135.  
  2136.             switch(rc = ChangeMessage(client, &CurrentMessage, &CurrentHeader, CurrentArea, bOldMsgLocal))
  2137.             {
  2138.                /* Alles OK */
  2139.                case 0:
  2140.                   SwitchEditor(client, CurrentArea, FALSE);
  2141.                   CurrentStatus = PROGSTATUS_READING;
  2142.                   StatusChanged(client, CurrentStatus);
  2143.                   NewMessage=FALSE;
  2144.                   MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  2145.                   pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  2146.                   UpdateDisplay(FALSE, TRUE);
  2147.                   break;
  2148.  
  2149.                default:
  2150.                   SaveErrorMessage(client, rc);
  2151.                   return;
  2152.             }
  2153.             SendMsg(client, WORKM_ENABLEVIEWS, NULL, NULL);
  2154.          }
  2155.          NewMessage=FALSE;
  2156.          break;
  2157.  
  2158.       case IDM_EXIT:
  2159.       case IDA_END:
  2160.          WinPostMsg(client, WM_CLOSE, NULL, NULL);
  2161.          break;
  2162.  
  2163.       case IDM_FILESHELL:
  2164.       case IDB_SHELL:
  2165.          bIgnoreActivate = TRUE;
  2166.          StartShell();
  2167.          bIgnoreActivate = FALSE;
  2168.          break;
  2169.  
  2170.       case IDM_FILEPRINTSETUP:
  2171.          PrintSetup.cb = sizeof(PrintSetup);
  2172.          WinDlgBox(HWND_DESKTOP, client, PrintSetupProc, hmodLang, IDD_PRINTSETUP,
  2173.                    &PrintSetup);
  2174.          break;
  2175.  
  2176.       case IDM_HELPABOUT:
  2177.          WinDlgBox(HWND_DESKTOP,
  2178.                    client,
  2179.                    AboutProc,
  2180.                    hmodLang,
  2181.                    IDD_HELPABOUT,
  2182.                    NULL);
  2183.          break;
  2184.  
  2185.       case IDM_HELPKEYS:
  2186.          if (hwndhelp)
  2187.             SendMsg(hwndhelp, HM_KEYS_HELP, NULL, NULL);
  2188.          break;
  2189.  
  2190.       case IDM_HELPUSING:
  2191.          if (hwndhelp)
  2192.             SendMsg(hwndhelp, HM_DISPLAY_HELP, NULL, NULL);
  2193.          break;
  2194.  
  2195.       case IDM_HELPINDEX:
  2196.          if (hwndhelp)
  2197.             SendMsg(hwndhelp, HM_HELP_INDEX, NULL, NULL);
  2198.          break;
  2199.  
  2200.       case IDM_HELPCONTENTS:
  2201.          if (hwndhelp)
  2202.             SendMsg(hwndhelp, HM_HELP_CONTENTS, NULL, NULL);
  2203.          break;
  2204.  
  2205.       case IDB_HELP:
  2206.       case IDM_HELPGENERAL:
  2207.          if (hwndhelp)
  2208.             SendMsg(hwndhelp, HM_GENERAL_HELP, NULL, NULL);
  2209.          break;
  2210.  
  2211.       case IDM_OPCONFIG:
  2212.          MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  2213.          strcpy(MessageID.pchAreaTag, CurrentArea);
  2214.          MessageID.ulMsgID=pWindowData->ulCurrentID;
  2215.          SendMsg(client, WORKM_READ, &MessageID, NULL);
  2216.  
  2217.          /* Area-Scan stoppen */
  2218.          if (DoingAreaScan)
  2219.          {
  2220.             StopAreaScan=TRUE;
  2221.             DosWaitThread((PTID) &tidAreaScan, DCWW_WAIT);
  2222.          }
  2223.          /* Find stoppen */
  2224.          if (DoingFind)
  2225.          {
  2226.             StopFind=TRUE;
  2227.             DosWaitThread((PTID) &tidFind, DCWW_WAIT);
  2228.          }
  2229.          /* Thread-Listen-Thread beenden */
  2230.          if (DoingInsert)
  2231.          {
  2232.             StopInsert=TRUE;
  2233.             DosWaitThread((PTID) &tidThreadList, DCWW_WAIT);
  2234.          }
  2235.          if (hwndThreadList)
  2236.          {
  2237.             WinDestroyWindow(hwndThreadList);
  2238.             hwndThreadList=NULLHANDLE;
  2239.          }
  2240.          if (hwndMsgList)
  2241.          {
  2242.             WinDestroyWindow(hwndMsgList);
  2243.             hwndMsgList=NULLHANDLE;
  2244.          }
  2245.          if (hwndAreaDlg)
  2246.          {
  2247.             WinDestroyWindow(hwndAreaDlg);
  2248.             hwndAreaDlg = NULLHANDLE;
  2249.          }
  2250.          if (hwndRxFolder)
  2251.          {
  2252.             WinDestroyWindow(hwndRxFolder);
  2253.             hwndRxFolder = NULLHANDLE;
  2254.          }
  2255.          if (hwndFindResults)
  2256.          {
  2257.             WinDestroyWindow(hwndFindResults);
  2258.             hwndFindResults = NULLHANDLE;
  2259.          }
  2260.          if (hwndNLBrowser)
  2261.          {
  2262.             WinDestroyWindow(hwndNLBrowser);
  2263.             hwndNLBrowser = NULLHANDLE;
  2264.          }
  2265.          if (hwndRequester)
  2266.             SendMsg(hwndRequester, WM_CLOSE, NULL, NULL);
  2267.          /* Api schliessen, alle Handles freigeben */
  2268.          MSG_CloseApi(&arealiste, &driveremap);
  2269.  
  2270.          /* Farben f. Editor */
  2271.          QueryBackground(WinWindowFromID(client, IDML_MAINEDIT), &windowcolors.viewerback);
  2272.          QueryForeground(WinWindowFromID(client, IDML_MAINEDIT), &windowcolors.viewerfore);
  2273.          WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_QUERYCOLOR,
  2274.                            MPFROMLONG(MSGVCLR_QUOTE),
  2275.                            MPFROMLONG(&windowcolors.viewerquote));
  2276.          WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_QUERYCOLOR,
  2277.                            MPFROMLONG(MSGVCLR_TEARLINE),
  2278.                            MPFROMLONG(&windowcolors.viewertearline));
  2279.          WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_QUERYCOLOR,
  2280.                            MPFROMLONG(MSGVCLR_ORIGIN),
  2281.                            MPFROMLONG(&windowcolors.viewerorigin));
  2282.  
  2283.          WinDlgBox(HWND_DESKTOP,
  2284.                    client,
  2285.                    OptionsProc,
  2286.                    hmodLang,
  2287.                    IDD_SETUPOPTIONS,
  2288.                    NULL);
  2289.          if (CurrentStatus == PROGSTATUS_NOSETUP &&
  2290.              (userdaten.address[0][0] && userdaten.username[0][0]))
  2291.          {
  2292.             CurrentStatus = PROGSTATUS_READING;
  2293.             StatusChanged(client, CurrentStatus);
  2294.          }
  2295.          if (CurrentStatus == PROGSTATUS_READING &&
  2296.              (!userdaten.address[0][0] || !userdaten.username[0][0]))
  2297.          {
  2298.             CurrentStatus = PROGSTATUS_NOSETUP;
  2299.             StatusChanged(client, CurrentStatus);
  2300.          }
  2301.  
  2302.          /* Farben f. Editor */
  2303.          WinEnableWindowUpdate(WinWindowFromID(client, IDML_MAINEDIT), FALSE);
  2304.          SetBackground(WinWindowFromID(client, IDML_MAINEDIT), &windowcolors.viewerback);
  2305.          SetForeground(WinWindowFromID(client, IDML_MAINEDIT), &windowcolors.viewerfore);
  2306.          WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_SETCOLOR,
  2307.                            MPFROMLONG(MSGVCLR_QUOTE),
  2308.                            MPFROMLONG(windowcolors.viewerquote));
  2309.          WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_SETCOLOR,
  2310.                            MPFROMLONG(MSGVCLR_TEARLINE),
  2311.                            MPFROMLONG(windowcolors.viewertearline));
  2312.          WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_SETCOLOR,
  2313.                            MPFROMLONG(MSGVCLR_ORIGIN),
  2314.                            MPFROMLONG(windowcolors.viewerorigin));
  2315.          WinEnableWindowUpdate(WinWindowFromID(client, IDML_MAINEDIT), TRUE);
  2316.  
  2317.          /* Api wieder oeffnen */
  2318.          MSG_OpenApi(userdaten.address[0]);
  2319.          SwitchToArea(CurrentArea);
  2320.          NewMessage=FALSE;
  2321.          break;
  2322.  
  2323.       case IDM_OPTEMPLATE:
  2324.          if (hwndTemplates)
  2325.             SetFocusControl(hwndTemplates, IDD_TPLFOLDER+1);
  2326.          else
  2327.             hwndTemplates = WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP, TemplateFolderProc, hmodLang,
  2328.                                        IDD_TPLFOLDER, NULL);
  2329.          break;
  2330.  
  2331.       case IDM_OPNICKNAMES:
  2332.          WinDlgBox(HWND_DESKTOP, client, AdrBookProc, hmodLang, IDD_NICKNAMES, NULL);
  2333.          break;
  2334.  
  2335.       case IDM_MSGMOVE:
  2336.       case IDB_MOVEMSG:
  2337.       case IDA_MOVE:
  2338.          if (CurrentStatus==PROGSTATUS_READING &&
  2339.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  2340.          {
  2341.             AreaListPar.cb=sizeof(AREALISTPAR);
  2342.             if (generaloptions.LastMoveArea[0])
  2343.                AreaListPar.pchString=strdup(generaloptions.LastMoveArea);
  2344.             else
  2345.                AreaListPar.pchString=strdup(CurrentArea);
  2346.             AreaListPar.idTitle = IDST_TITLE_AL_MOVE;
  2347.             AreaListPar.ulIncludeTypes = INCLUDE_ALL;
  2348.             AreaListPar.bExtendedSel = FALSE;
  2349.             AreaListPar.bChange      = FALSE;
  2350.  
  2351.             if (WinDlgBox(HWND_DESKTOP, client,
  2352.                           AreaListProc, hmodLang,
  2353.                           IDD_AREALIST, &AreaListPar)==DID_OK && AreaListPar.pchString)
  2354.             {
  2355.                MSGLISTPAR MsgListPar;
  2356.                int rc;
  2357.                ULONG ulOptions=0;
  2358.  
  2359.                zeiger = AM_FindArea(&arealiste, AreaListPar.pchString);
  2360.                if (zeiger && zeiger->areadata.areatype != AREATYPE_LOCAL)
  2361.                   switch(MessageBox(client, IDST_MSG_RESEND, IDST_TITLE_RESEND,
  2362.                                     IDD_RESEND, MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2))
  2363.                   {
  2364.                      case MBID_YES:
  2365.                         ulOptions = COPYMOVE_RESEND;
  2366.                         break;
  2367.  
  2368.                      default:
  2369.                         break;
  2370.                   }
  2371.  
  2372.                if (!MSG_OpenArea(&arealiste, AreaListPar.pchString, miscoptions.lastreadoffset, &driveremap))
  2373.                {
  2374.                   if (rc=MSG_MoveMessage(&CurrentMessage, &CurrentHeader, &arealiste,
  2375.                                          CurrentArea, AreaListPar.pchString, 0,
  2376.                                          &driveremap, &userdaten, &generaloptions, SendAddMessage,
  2377.                                          SendKillMessage, ulOptions))
  2378.                   {
  2379.                      char message[200];
  2380.                      sprintf(message, "Fehler %d beim Moven!", rc);
  2381.                      QuickMessage(client, message);
  2382.                   }
  2383.                   else
  2384.                   {
  2385.                      Notify(client, IDST_NOT_MOVED);
  2386.                      strcpy(generaloptions.LastMoveArea, AreaListPar.pchString);
  2387.  
  2388.                      AM_FindArea(&arealiste, AreaListPar.pchString)->mailentered=TRUE;
  2389.                      MailEntered[AM_FindArea(&arealiste, AreaListPar.pchString)->areadata.areatype] = TRUE;
  2390.                   }
  2391.                   MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  2392.                   MsgListPar.msgnum=MSG_MsgnToUid(&arealiste, CurrentArea, QueryCurrent(&arealiste, CurrentArea));
  2393.                   pWindowData->ulCurrentID= MsgListPar.msgnum;
  2394.                   NewMessage=FALSE;
  2395.                   UpdateDisplay(FALSE, TRUE);
  2396.                   MSG_CloseArea(&arealiste, AreaListPar.pchString, TRUE, miscoptions.lastreadoffset, &driveremap);
  2397.                }
  2398.                free(AreaListPar.pchString);
  2399.             }
  2400.          }
  2401.          break;
  2402.  
  2403.       case IDM_MSGCOPY:
  2404.       case IDB_COPYMSG:
  2405.       case IDA_COPY:
  2406.          if (CurrentStatus==PROGSTATUS_READING &&
  2407.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  2408.          {
  2409.             AreaListPar.cb=sizeof(AREALISTPAR);
  2410.             if (generaloptions.LastCopyArea[0])
  2411.                AreaListPar.pchString=strdup(generaloptions.LastCopyArea);
  2412.             else
  2413.                AreaListPar.pchString=strdup(CurrentArea);
  2414.             AreaListPar.idTitle = IDST_TITLE_AL_COPY;
  2415.             AreaListPar.ulIncludeTypes = INCLUDE_ALL;
  2416.             AreaListPar.bExtendedSel = FALSE;
  2417.             AreaListPar.bChange      = FALSE;
  2418.  
  2419.             if (WinDlgBox(HWND_DESKTOP, client,
  2420.                           AreaListProc, hmodLang,
  2421.                           IDD_AREALIST, &AreaListPar)==DID_OK && AreaListPar.pchString)
  2422.             {
  2423.                ULONG ulOptions=0;
  2424.  
  2425.                zeiger = AM_FindArea(&arealiste, AreaListPar.pchString);
  2426.                if (zeiger && zeiger->areadata.areatype != AREATYPE_LOCAL)
  2427.                   switch(MessageBox(client, IDST_MSG_RESEND, IDST_TITLE_RESEND,
  2428.                                     IDD_RESEND, MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2))
  2429.                   {
  2430.                      case MBID_YES:
  2431.                         ulOptions = COPYMOVE_RESEND;
  2432.                         break;
  2433.  
  2434.                      default:
  2435.                         break;
  2436.                   }
  2437.  
  2438.                if (!MSG_OpenArea(&arealiste, AreaListPar.pchString, miscoptions.lastreadoffset, &driveremap))
  2439.                {
  2440.                   if (MSG_CopyMessage(&CurrentMessage, &CurrentHeader, &arealiste,
  2441.                                       AreaListPar.pchString, &driveremap, &userdaten, &generaloptions, SendAddMessage, ulOptions))
  2442.                      QuickMessage(client, "Fehler Message kopieren!");
  2443.                   else
  2444.                   {
  2445.                      Notify(client, IDST_NOT_COPIED);
  2446.                      strcpy(generaloptions.LastCopyArea, AreaListPar.pchString);
  2447.                      AM_FindArea(&arealiste, AreaListPar.pchString)->mailentered=TRUE;
  2448.                      MailEntered[AM_FindArea(&arealiste, AreaListPar.pchString)->areadata.areatype]=TRUE;
  2449.                   }
  2450.                   NewMessage=FALSE;
  2451.                   MSG_CloseArea(&arealiste, AreaListPar.pchString, TRUE, miscoptions.lastreadoffset, &driveremap);
  2452.                }
  2453.                free(AreaListPar.pchString);
  2454.             }
  2455.          }
  2456.          break;
  2457.  
  2458.       case IDM_MSGFORWARD:
  2459.       case IDB_FORWARD:
  2460.       case IDA_FORWARD:
  2461.          if (CurrentStatus==PROGSTATUS_READING &&
  2462.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  2463.          {
  2464.             AreaListPar.cb=sizeof(AREALISTPAR);
  2465.             if (generaloptions.LastForwardArea[0])
  2466.                AreaListPar.pchString=strdup(generaloptions.LastForwardArea);
  2467.             else
  2468.                AreaListPar.pchString=strdup(CurrentArea);
  2469.             AreaListPar.idTitle = IDST_TITLE_AL_FORWARD;
  2470.             AreaListPar.ulIncludeTypes = INCLUDE_ALL;
  2471.             AreaListPar.bExtendedSel = FALSE;
  2472.             AreaListPar.bChange      = FALSE;
  2473.  
  2474.             if (WinDlgBox(HWND_DESKTOP, client,
  2475.                           AreaListProc, hmodLang,
  2476.                           IDD_AREALIST, &AreaListPar)==DID_OK && AreaListPar.pchString)
  2477.             {
  2478.                MSG_ForwardMessage(&templatelist, &CurrentMessage, &CurrentHeader,
  2479.                                   &arealiste, CurrentArea,
  2480.                                   AreaListPar.pchString,
  2481.                                   CurrentName, generaloptions.genFwdSubj);
  2482.                strcpy(NewArea, AreaListPar.pchString);
  2483.                strcpy(generaloptions.LastForwardArea, AreaListPar.pchString);
  2484.                NewMessage=TRUE;
  2485.                bTemplateProcessed=FALSE;
  2486.                ulTemplateType=TPLTYPE_FORWARD;
  2487.                iptInitialPos2=0;
  2488.  
  2489.                SwitchEditor(client, NewArea, TRUE);
  2490.                CurrentStatus = PROGSTATUS_EDITING;
  2491.                UpdateDisplay(TRUE, FALSE);
  2492.                StatusChanged(client, CurrentStatus);
  2493.                SetFocusControl(client, IDE_TONAME);
  2494.                free(AreaListPar.pchString);
  2495.             }
  2496.          }
  2497.          break;
  2498.  
  2499.       case IDM_MSGREQUEST:
  2500.       case IDB_REQUEST:
  2501.       case IDA_REQUEST:
  2502.          if (CurrentStatus==PROGSTATUS_READING && !hwndRequester &&
  2503.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  2504.          {
  2505.             SendMsg(client, WORKM_DISABLEVIEWS, NULL, NULL);
  2506.             pRequestPar=calloc(1, sizeof(REQUESTPAR));
  2507.             pRequestPar->cb=sizeof(STRINGPAR);
  2508.             pRequestPar->pchFiles = CurrentMessage.pchMessageText;
  2509.             WinQueryDlgItemText(client, IDE_FROMADDRESS, LEN_5DADDRESS+1, pRequestPar->pchReqAddr);
  2510.             WinQueryDlgItemText(client, IDE_FROMNAME, LEN_USERNAME+1, pRequestPar->pchReqName);
  2511.             strcpy(pRequestPar->pchDestArea, requestoptions.pchDestArea);
  2512.             pRequestPar->arealist=&arealiste;
  2513.             pRequestPar->bDirect = requestoptions.bDirectReq;
  2514.             pRequestPar->ulAttrib =  requestoptions.ulAttrib;
  2515.  
  2516.             hwndRequester=WinLoadDlg(HWND_DESKTOP, client, RequestProc,
  2517.                                      hmodLang, IDD_REQUESTER, pRequestPar);
  2518.          }
  2519.          break;
  2520.  
  2521.       case IDM_MSGXPOST:
  2522.       case IDA_CROSSPOST:
  2523.          if (CurrentStatus==PROGSTATUS_EDITING && NewMessage)
  2524.          {
  2525.             if (ulCCSelected || pQuickCCList)
  2526.                break;
  2527.             if (AM_FindArea(&arealiste, NewMessage?NewArea:CurrentArea)->areadata.areatype == AREATYPE_NET)
  2528.                break;
  2529.             if (pchXPostList==NULL)
  2530.             {
  2531.                AreaListPar.cb=sizeof(AREALISTPAR);
  2532.                AreaListPar.pchString=NULL;
  2533.                AreaListPar.idTitle = IDST_TITLE_AL_XPOST;
  2534.                AreaListPar.ulIncludeTypes = INCLUDE_ECHO | INCLUDE_LOCAL;
  2535.                AreaListPar.bExtendedSel = TRUE;
  2536.                AreaListPar.bChange      = FALSE;
  2537.                if (WinDlgBox(HWND_DESKTOP, client,
  2538.                              AreaListProc, hmodLang,
  2539.                              IDD_AREALIST, &AreaListPar)==DID_OK && AreaListPar.pchString)
  2540.                {
  2541.                   pchXPostList=AreaListPar.pchString;
  2542.                }
  2543.             }
  2544.             else
  2545.             {
  2546.                free(pchXPostList);
  2547.                pchXPostList=NULL;
  2548.                Notify(client, IDST_NOT_XPDESELECT);
  2549.             }
  2550.          }
  2551.          break;
  2552.  
  2553.       case IDM_EDITSEARCH:
  2554.          SearchPar.cb = sizeof(SearchPar);
  2555.  
  2556.          if (WinDlgBox(HWND_DESKTOP, client, SearchProc, hmodLang,
  2557.                        IDD_SEARCH, &SearchPar) == DID_OK)
  2558.          {
  2559.             if (!SearchInMessage(client, &SearchPar))
  2560.                Notify(client, IDST_NOT_STRINGNOTFOUND);
  2561.          }
  2562.          break;
  2563.  
  2564.       case IDM_OPNAMEADDR:
  2565.       case IDA_DEFAULTADDR:
  2566.          if (CurrentStatus == PROGSTATUS_NOSETUP)
  2567.             break;
  2568.  
  2569.          CurrNamePar.cb=sizeof(CURRNAMEPAR);
  2570.          strcpy(CurrNamePar.CurrName, CurrentName);
  2571.          strcpy(CurrNamePar.CurrAddr, CurrentAddress);
  2572.          if (WinDlgBox(HWND_DESKTOP, client,
  2573.                        CurrNameProc, hmodLang, IDD_CURRENTNAMEADDR,
  2574.                        &CurrNamePar)==DID_OK)
  2575.          {
  2576.             /* Name und Adresse uebernehmen */
  2577.             strcpy(CurrentName, CurrNamePar.CurrName);
  2578.             strcpy(CurrentAddress, CurrNamePar.CurrAddr);
  2579.             WinSendDlgItemMsg(frame, FID_STATUSLINE, STLM_SETFIELDTEXT,
  2580.                               MPFROMLONG(pWindowData->idAddressField),
  2581.                               CurrentAddress);
  2582.  
  2583.             if (CurrentStatus==PROGSTATUS_EDITING)
  2584.             {
  2585.                WinSetDlgItemText(client, IDE_FROMNAME, CurrentName);
  2586.                WinSetDlgItemText(client, IDE_FROMADDRESS, CurrentAddress);
  2587.             }
  2588.          }
  2589.          break;
  2590.  
  2591.       case IDM_OPSAVE:
  2592.          if (!issecondinstance)
  2593.             _beginthread(SaveIniProfileThread, NULL, 32768, NULL);
  2594.          else
  2595.             WinAlarm(HWND_DESKTOP, WA_ERROR);
  2596.          break;
  2597.  
  2598.       case IDM_MSGMARK:
  2599.       case IDB_CATCHUP:
  2600.       case IDA_CATCHUP:
  2601.          if (CurrentStatus == PROGSTATUS_READING &&
  2602.              pWindowData->pArea && pWindowData->pArea->maxmessages)
  2603.          {
  2604.             if (bDoingWork)
  2605.                MessageBox(client, IDST_MSG_DOINGWORK, 0, IDD_DOINGWORK, MB_OK);
  2606.             else
  2607.             {
  2608.                if (generaloptions.safety & SAFETY_CATCHUP)
  2609.                   if (MessageBox(client, IDST_MSG_CATCHUP, IDST_TITLE_CATCHUP,
  2610.                                  IDD_CATCHUP, MB_YESNO) != MBID_YES)
  2611.                      break;
  2612.                MarkAllMessages(CurrentArea);
  2613.             }
  2614.          }
  2615.          break;
  2616.  
  2617.       case IDM_OPCCLISTS:
  2618.          if (!hwndCCLists)
  2619.             hwndCCLists = WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP, CCFolderProc,
  2620.                                      hmodLang, IDD_CCFOLDER, NULL);
  2621.          else
  2622.             SetFocus(hwndCCLists);
  2623.          break;
  2624.  
  2625.       case IDM_WINAREAS:
  2626.       case IDM_WINMSGLIST:
  2627.       case IDM_WINTHREADS:
  2628.       case IDM_WINKLUDGES:
  2629.       case IDM_WINPROGRESS:
  2630.          ShowFleetWindow(CommandID);
  2631.          break;
  2632.  
  2633.       case IDM_WINRESULTS:
  2634.       case IDB_BOOKMARKS:
  2635.       case IDA_BOOKMARKS:
  2636.          if (pWindowData->pArea)
  2637.             ShowFleetWindow(IDM_WINRESULTS);
  2638.          break;
  2639.  
  2640.       case IDM_MSGCCOPY:
  2641.       case IDA_CCOPY:
  2642.          if (CurrentStatus==PROGSTATUS_EDITING && NewMessage)
  2643.          {
  2644.             if (pchXPostList)
  2645.                break;             /* Kein CC und XP gleichzeitig */
  2646.             zeiger= AM_FindArea(&arealiste, NewMessage? NewArea:CurrentArea);
  2647.             if (zeiger->areadata.areatype == AREATYPE_ECHO)
  2648.                break;
  2649.             if (ulCCSelected)
  2650.             {
  2651.                /* CC abschalten */
  2652.  
  2653.                ulCCSelected=0;
  2654.                WinSendDlgItemMsg(client, IDE_TONAME, EM_SETREADONLY, (MPARAM) FALSE, NULL);
  2655.                WinSendDlgItemMsg(client, IDE_TOADDRESS, EM_SETREADONLY, (MPARAM) FALSE, NULL);
  2656.                WinSetDlgItemText(client, IDE_TOADDRESS, SaveToAddress);
  2657.                WinSetDlgItemText(client, IDE_TONAME, SaveToName);
  2658.                Notify(client, IDST_NOT_CCDESELECT);
  2659.             }
  2660.             else
  2661.             {
  2662.                CCSelectPar.cb=sizeof(CCSELECTPAR);
  2663.                CCSelectPar.ulSelectID = 0;
  2664.                CCSelectPar.bEmptyLists=FALSE;
  2665.                if (WinDlgBox(HWND_DESKTOP, client, CCListSelectProc, hmodLang,
  2666.                          IDD_CCLISTSELECT, &CCSelectPar)==DID_OK)
  2667.                {
  2668.                   if (CCSelectPar.ulSelectID)
  2669.                   {
  2670.                      char *pchTemp, *pchDst, *pchSrc;
  2671.                      PCCLIST pList;
  2672.  
  2673.                      ulCCSelected=CCSelectPar.ulSelectID;
  2674.                      pList = QueryCCList(&ccanchor, ulCCSelected);
  2675.  
  2676.                      /* Name vorbereiten */
  2677.                      pchTemp = malloc(strlen(pList->pchListName)+10);
  2678.                      strcpy(pchTemp, "** ");
  2679.                      pchDst=strchr(pchTemp, 0);
  2680.                      pchSrc =pList->pchListName;
  2681.                      while (*pchSrc)
  2682.                      {
  2683.                         switch(*pchSrc)
  2684.                         {
  2685.                            case '\r':
  2686.                               break;
  2687.  
  2688.                            case '\n':
  2689.                               *pchDst++ = ' ';
  2690.                               break;
  2691.  
  2692.                            default:
  2693.                               *pchDst++ = *pchSrc;
  2694.                               break;
  2695.                         }
  2696.                         pchSrc++;
  2697.                      }
  2698.                      *pchDst=0;
  2699.                      strcat(pchTemp, " **");
  2700.                      WinSetDlgItemText(client, IDE_TONAME, pchTemp);
  2701.                      free(pchTemp);
  2702.  
  2703.                      WinQueryDlgItemText(client, IDE_TONAME, LEN_USERNAME+1, SaveToName);
  2704.                      WinQueryDlgItemText(client, IDE_TOADDRESS, LEN_5DADDRESS+1, SaveToAddress);
  2705.                      WinSendDlgItemMsg(client, IDE_TONAME, EM_SETREADONLY, (MPARAM) TRUE, NULL);
  2706.                      WinSendDlgItemMsg(client, IDE_TOADDRESS, EM_SETREADONLY, (MPARAM) TRUE, NULL);
  2707.                      WinSetDlgItemText(client, IDE_TOADDRESS, "");
  2708.                   }
  2709. #ifdef DEBUG
  2710.                   else
  2711.                      WinAlarm(HWND_DESKTOP, WA_ERROR);
  2712. #endif
  2713.                }
  2714.             }
  2715.          }
  2716.          break;
  2717.  
  2718.       case IDM_MSGQUICKCC:
  2719.          if (!pQuickCCList)
  2720.          {
  2721.             CCLISTPAR CCListPar;
  2722.  
  2723.             pQuickCCList = malloc(sizeof(CCLIST));
  2724.             memset(pQuickCCList, 0, sizeof(CCLIST));
  2725.  
  2726.             pQuickCCList->pchListName = malloc(100);
  2727.             LoadString(IDST_CC_QUICKCC, 100, pQuickCCList->pchListName);
  2728.  
  2729.             CCListPar.cb = sizeof(CCListPar);
  2730.             CCListPar.pList = pQuickCCList;
  2731.             CCListPar.pCCAnchor = NULL;
  2732.  
  2733.             if (WinDlgBox(HWND_DESKTOP, client, CCListContentsProc, hmodLang,
  2734.                       IDD_CCLIST, &CCListPar)!= DID_OK)
  2735.             {
  2736.                while(pQuickCCList->pEntries)
  2737.                   DeleteCCEntry(NULL, pQuickCCList, pQuickCCList->pEntries);
  2738.                free(pQuickCCList->pchListName);
  2739.                free(pQuickCCList);
  2740.                pQuickCCList=NULL;
  2741.                Notify(client, IDST_NOT_CCDESELECT);
  2742.             }
  2743.             else
  2744.             {
  2745.                char *pchTemp;
  2746.  
  2747.                pchTemp = malloc(strlen(pQuickCCList->pchListName)+10);
  2748.                strcpy(pchTemp, "** ");
  2749.                strcat(pchTemp, pQuickCCList->pchListName);
  2750.                strcat(pchTemp, " **");
  2751.                WinQueryDlgItemText(client, IDE_TONAME, LEN_USERNAME+1, SaveToName);
  2752.                WinQueryDlgItemText(client, IDE_TOADDRESS, LEN_5DADDRESS+1, SaveToAddress);
  2753.                WinSendDlgItemMsg(client, IDE_TONAME, EM_SETREADONLY, (MPARAM) TRUE, NULL);
  2754.                WinSendDlgItemMsg(client, IDE_TOADDRESS, EM_SETREADONLY, (MPARAM) TRUE, NULL);
  2755.                WinSetDlgItemText(client, IDE_TOADDRESS, "");
  2756.                WinSetDlgItemText(client, IDE_TONAME, pchTemp);
  2757.                free(pchTemp);
  2758.             }
  2759.          }
  2760.          else
  2761.          {
  2762.             SHORT sRet;
  2763.  
  2764.             sRet = MessageBox(client, IDST_MSG_MODQUICKCC, IDST_TITLE_MODQUICKCC,
  2765.                               IDD_MODQUICKCC, MB_YESNOCANCEL | MB_QUERY);
  2766.             switch(sRet)
  2767.             {
  2768.                CCLISTPAR CCListPar;
  2769.  
  2770.                case MBID_YES:
  2771.                   CCListPar.cb = sizeof(CCListPar);
  2772.                   CCListPar.pList = pQuickCCList;
  2773.                   CCListPar.pCCAnchor = NULL;
  2774.  
  2775.                   WinDlgBox(HWND_DESKTOP, client, CCListContentsProc, hmodLang,
  2776.                             IDD_CCLIST, &CCListPar);
  2777.                   break;
  2778.  
  2779.                case MBID_NO:
  2780.                   while(pQuickCCList->pEntries)
  2781.                      DeleteCCEntry(NULL, pQuickCCList, pQuickCCList->pEntries);
  2782.                   free(pQuickCCList->pchListName);
  2783.                   free(pQuickCCList);
  2784.                   pQuickCCList=NULL;
  2785.  
  2786.                   WinSendDlgItemMsg(client, IDE_TONAME, EM_SETREADONLY, (MPARAM) FALSE, NULL);
  2787.                   WinSendDlgItemMsg(client, IDE_TOADDRESS, EM_SETREADONLY, (MPARAM) FALSE, NULL);
  2788.                   WinSetDlgItemText(client, IDE_TOADDRESS, SaveToAddress);
  2789.                   WinSetDlgItemText(client, IDE_TONAME, SaveToName);
  2790.                   Notify(client, IDST_NOT_CCDESELECT);
  2791.                   break;
  2792.  
  2793.                default:
  2794.                   break;
  2795.             }
  2796.          }
  2797.          break;
  2798.  
  2799.       case IDM_FILEECHOTOSS:
  2800.          if (echotossoptions.useechotoss &&
  2801.              echotossoptions.pchEchoToss[0])
  2802.             if (WriteEchotoss(&arealiste, echotossoptions.pchEchoToss))
  2803.                MessageBox(client, IDST_MSG_ETOSSERROR, 0, IDD_ETOSSERROR,
  2804.                           MB_ERROR | MB_OK);
  2805.          break;
  2806.  
  2807.       case IDM_EP_COPY:
  2808.          switch(pWindowData->usPopupControl)
  2809.          {
  2810.             case IDML_MAINEDIT:
  2811.                WinSendDlgItemMsg(client, IDML_MAINEDIT, MLM_COPY, NULL, NULL);
  2812.                break;
  2813.  
  2814.             case IDE_FROMNAME:
  2815.             case IDE_FROMADDRESS:
  2816.             case IDE_TONAME:
  2817.             case IDE_TOADDRESS:
  2818.             case IDE_SUBJTEXT:
  2819.                WinSendDlgItemMsg(client, pWindowData->usPopupControl,
  2820.                                  EM_COPY, NULL, NULL);
  2821.                break;
  2822.  
  2823.             default:
  2824.                break;
  2825.          }
  2826.          break;
  2827.  
  2828.       case IDM_EP_CUT:
  2829.          switch(pWindowData->usPopupControl)
  2830.          {
  2831.             case IDML_MAINEDIT:
  2832.                WinSendDlgItemMsg(client, IDML_MAINEDIT, MLM_CUT, NULL, NULL);
  2833.                break;
  2834.  
  2835.             case IDE_FROMNAME:
  2836.             case IDE_FROMADDRESS:
  2837.             case IDE_TONAME:
  2838.             case IDE_TOADDRESS:
  2839.             case IDE_SUBJTEXT:
  2840.                WinSendDlgItemMsg(client, pWindowData->usPopupControl,
  2841.                                  EM_CUT, NULL, NULL);
  2842.                break;
  2843.  
  2844.             default:
  2845.                break;
  2846.          }
  2847.          break;
  2848.  
  2849.       case IDM_EP_PASTE:
  2850.          switch(pWindowData->usPopupControl)
  2851.          {
  2852.             case IDML_MAINEDIT:
  2853.                WinSendDlgItemMsg(client, IDML_MAINEDIT, MLM_PASTE, NULL, NULL);
  2854.                break;
  2855.  
  2856.             case IDE_FROMNAME:
  2857.             case IDE_FROMADDRESS:
  2858.             case IDE_TONAME:
  2859.             case IDE_TOADDRESS:
  2860.             case IDE_SUBJTEXT:
  2861.                WinSendDlgItemMsg(client, pWindowData->usPopupControl,
  2862.                                  EM_PASTE, NULL, NULL);
  2863.                break;
  2864.  
  2865.             default:
  2866.                break;
  2867.          }
  2868.          break;
  2869.  
  2870.       case IDM_EP_UNDO:
  2871.          switch(pWindowData->usPopupControl)
  2872.          {
  2873.             case IDML_MAINEDIT:
  2874.                WinSendDlgItemMsg(client, IDML_MAINEDIT, MLM_UNDO, NULL, NULL);
  2875.                break;
  2876.  
  2877.             default:
  2878.                break;
  2879.          }
  2880.          break;
  2881.  
  2882.       case IDM_EP_CLEAR:
  2883.          switch(pWindowData->usPopupControl)
  2884.          {
  2885.             case IDML_MAINEDIT:
  2886.                WinSendDlgItemMsg(client, IDML_MAINEDIT, MLM_CLEAR, NULL, NULL);
  2887.                break;
  2888.  
  2889.             case IDE_FROMNAME:
  2890.             case IDE_FROMADDRESS:
  2891.             case IDE_TONAME:
  2892.             case IDE_TOADDRESS:
  2893.             case IDE_SUBJTEXT:
  2894.                WinSendDlgItemMsg(client, pWindowData->usPopupControl,
  2895.                                  EM_CLEAR, NULL, NULL);
  2896.                break;
  2897.  
  2898.             default:
  2899.                break;
  2900.          }
  2901.          break;
  2902.  
  2903.       case IDM_EP_DELLINE:
  2904.          switch(pWindowData->usPopupControl)
  2905.          {
  2906.             case IDML_MAINEDIT:
  2907.                WinSendDlgItemMsg(client, IDML_MAINEDIT, MLM_DELETELINE, NULL, NULL);
  2908.                break;
  2909.  
  2910.             default:
  2911.                break;
  2912.          }
  2913.          break;
  2914.  
  2915.       case IDM_EP_HIGHLIGHT:
  2916.          switch(pWindowData->usPopupControl)
  2917.          {
  2918.             case IDML_MAINEDIT:
  2919.                if (WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_QUERYHIGHLIGHT, NULL, NULL))
  2920.                   WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_ENABLEHIGHLIGHT, MPFROMLONG(FALSE), NULL);
  2921.                else
  2922.                   WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_ENABLEHIGHLIGHT, MPFROMLONG(TRUE), NULL);
  2923.                break;
  2924.  
  2925.             default:
  2926.                break;
  2927.          }
  2928.          break;
  2929.  
  2930.       case IDM_EP_MONO:
  2931.          switch(pWindowData->usPopupControl)
  2932.          {
  2933.             case IDML_MAINEDIT:
  2934.                if (MonoDisp || TempMono)
  2935.                {
  2936.                   QueryControlFont(client, IDML_MAINEDIT, windowfonts.viewermonofont);
  2937.                   SetFont(WinWindowFromID(client, IDML_MAINEDIT), windowfonts.viewerfont);
  2938.                   MonoDisp = TempMono = FALSE;
  2939.                }
  2940.                else
  2941.                {
  2942.                   QueryControlFont(client, IDML_MAINEDIT, windowfonts.viewerfont);
  2943.                   SetFont(WinWindowFromID(client, IDML_MAINEDIT), windowfonts.viewermonofont);
  2944.                   MonoDisp = TRUE;
  2945.                }
  2946.                break;
  2947.  
  2948.             default:
  2949.                break;
  2950.          }
  2951.          break;
  2952.  
  2953.       case IDM_MSGBCDELETE:
  2954.          if (!MSG_BroadcastDelete(&arealiste, CurrentArea, &CurrentHeader,
  2955.                                   &CurrentMessage, &userdaten, &generaloptions,
  2956.                                   CurrentName, CurrentAddress,
  2957.                                   &driveremap, &templatelist, SendAddMessage))
  2958.          {
  2959.             MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  2960.             pWindowData->pArea->mailentered=TRUE;
  2961.             MailEntered[pWindowData->pArea->areadata.areatype]=TRUE;
  2962.          }
  2963.          else
  2964.          {
  2965.             /* Fehler */
  2966.             MessageBox(client, IDST_MSG_BCDELERROR, IDST_TITLE_BCDELERROR,
  2967.                        IDD_BCDELERROR, MB_OK | MB_ERROR);
  2968.          }
  2969.          MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  2970.          break;
  2971.  
  2972.       case IDM_MSGBCMODIFY:
  2973.          MSG_BroadcastModify(&CurrentHeader, &CurrentMessage);
  2974.          NewMessage=TRUE;
  2975.          SendMsg(client, WORKM_ENABLEVIEWS, NULL, NULL);
  2976.          strcpy(NewArea, CurrentArea);
  2977.          SwitchEditor(client, NewArea, TRUE);
  2978.          DisplayMsgText(client, &CurrentMessage);
  2979.          CurrentStatus = PROGSTATUS_EDITING;
  2980.          StatusChanged(client, CurrentStatus);
  2981.          SetFocusControl(client, IDML_MAINEDIT);
  2982.          break;
  2983.  
  2984.       case IDM_RXSCRIPTS:
  2985.       case IDB_SCRIPTS:
  2986.          if (hwndRxFolder)
  2987.             SetFocusControl(hwndRxFolder, IDD_RXFOLDER+1);
  2988.          else
  2989.          {
  2990.             hwndRxFolder = WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP, ScriptFolderProc,
  2991.                                           hmodLang, IDD_RXFOLDER, NULL);
  2992.             WinShowWindow(hwndRxFolder, TRUE);
  2993.          }
  2994.          break;
  2995.  
  2996.       case IDM_SPCADDTONICK:
  2997.       case IDA_ADDTONICK:
  2998.          if (pWindowData->pArea && pWindowData->pArea->maxmessages>0)
  2999.             AddToNick(client, &CurrentHeader);
  3000.          break;
  3001.  
  3002.       case IDM_SPCADDTOCC:
  3003.       case IDA_ADDTOCC:
  3004.          if (pWindowData->pArea && pWindowData->pArea->maxmessages>0 && ccanchor.ulNumLists)
  3005.             AddToCCList(client, &CurrentHeader);
  3006.          break;
  3007.  
  3008.       case IDM_RXQUICK1:
  3009.       case IDM_RXQUICK2:
  3010.       case IDM_RXQUICK3:
  3011.       case IDM_RXQUICK4:
  3012.       case IDM_RXQUICK5:
  3013.       case IDM_RXQUICK6:
  3014.       case IDM_RXQUICK7:
  3015.       case IDM_RXQUICK8:
  3016.       case IDM_RXQUICK9:
  3017.       case IDM_RXQUICK10:
  3018.          StartQuickRexx(CommandID);
  3019.          break;
  3020.  
  3021.       case IDM_SPCBROWSER:
  3022.       case IDB_BROWSER:
  3023.       case IDA_NLBROWSER:
  3024.          if (domains)
  3025.          {
  3026.             if (!hwndNLBrowser)
  3027.                hwndNLBrowser = WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP, NLBrowserProc,
  3028.                                           hmodLang, IDD_NLBROWSER, NULL);
  3029.             else
  3030.             {
  3031.                SWP swp;
  3032.  
  3033.                SetFocusControl(hwndNLBrowser, IDD_NLBROWSER+1);
  3034.                WinQueryWindowPos(hwndNLBrowser, &swp);
  3035.                if (swp.fl & SWP_MINIMIZE)
  3036.                   WinSetWindowPos(hwndNLBrowser,
  3037.                                   NULLHANDLE,
  3038.                                   0, 0, 0, 0,
  3039.                                   SWP_RESTORE);
  3040.             }
  3041.          }
  3042.          break;
  3043.  
  3044.       case IDM_MSGMARKMSG:
  3045.          if (!IsMessageMarked(&MarkerList, CurrentArea, pWindowData->ulCurrentID, MARKFLAG_MANUAL))
  3046.          {
  3047.             MarkMessage(&MarkerList, CurrentArea, pWindowData->ulCurrentID, QueryCurrent(&arealiste, CurrentArea),
  3048.                         &CurrentHeader, NULL, MARKFLAG_MANUAL, 0, 0);
  3049.             strcpy(MessageID.pchAreaTag, CurrentArea);
  3050.             MessageID.ulMsgID = pWindowData->ulCurrentID;
  3051.             SendMsg(client, WORKM_MSGMARKED, &MessageID, &CurrentHeader);
  3052.          }
  3053.          break;
  3054.  
  3055.       case IDM_MSGUNMARKMSG:
  3056.          if (IsMessageMarked(&MarkerList, CurrentArea, pWindowData->ulCurrentID, MARKFLAG_MANUAL))
  3057.          {
  3058.             UnmarkMessage(&MarkerList, CurrentArea, pWindowData->ulCurrentID, MARKFLAG_MANUAL);
  3059.             strcpy(MessageID.pchAreaTag, CurrentArea);
  3060.             MessageID.ulMsgID = pWindowData->ulCurrentID;
  3061.             SendMsg(client, WORKM_MSGUNMARKED, &MessageID, NULL);
  3062.          }
  3063.          break;
  3064.  
  3065.       case IDM_TB_TOP:
  3066.       case IDM_TB_BOTTOM:
  3067.       case IDM_TB_LEFT:
  3068.       case IDM_TB_RIGHT:
  3069.          SwitchToolbarPos(client, CommandID);
  3070.          break;
  3071.  
  3072.       case IDM_TB_SMALL:
  3073.          SwitchToolbarSize(client);
  3074.          break;
  3075.  
  3076.       case IDM_TB_ADD:
  3077.          ToolbarConfig.cb = sizeof(ToolbarConfig);
  3078.          if (WinDlgBox(HWND_DESKTOP, client, ToolbarConfigProc, hmodLang,
  3079.                    IDD_TOOLBARCONFIG, &ToolbarConfig) == DID_OK)
  3080.          {
  3081.             RefreshToolbar(WinWindowFromID(frame, FID_TOOLBAR), &ToolbarConfig,
  3082.                            ToolbarOptions.bSmallToolbar);
  3083.             StatusChanged(client, CurrentStatus);
  3084.             UpdateButtons(pWindowData->pArea);
  3085.             SendMsg(frame, WM_UPDATEFRAME, NULL, NULL);
  3086.          }
  3087.          break;
  3088.  
  3089.       case IDM_OPECHOMAN:
  3090.          SendMsg(client, WORKM_DISABLEVIEWS, NULL, NULL);
  3091.          WinDlgBox(HWND_DESKTOP, client, EchoMgrProc, hmodLang, IDD_ECHOMANAGER, NULL);
  3092.          SendMsg(client, WORKM_ENABLEVIEWS, NULL, NULL);
  3093.          break;
  3094.  
  3095.       case IDM_OPADDAREAS:
  3096.          if (generaloptions.safety & SAFETY_CHANGESETUP)
  3097.             if (MessageBox(client, IDST_MSG_DOEXTRACT, IDST_TITLE_DOEXTRACT, IDD_DOEXTRACT,
  3098.                            MB_YESNO | MB_QUERY) != MBID_YES)
  3099.                break;
  3100.          if (!ExtractUplinkFromMessage(client, &CurrentHeader, &CurrentMessage, &EchoMgrOpt))
  3101.             MessageBox(client, IDST_MSG_NOUPLINKAREAS, 0, IDD_NOUPLINKAREAS,
  3102.                        MB_ERROR | MB_OK);
  3103.          else
  3104.             Notify(client, IDST_NOT_EXTRACTED);
  3105.          break;
  3106.  
  3107.       case IDA_DELLINE:
  3108.          if (WinQueryFocus(HWND_DESKTOP)==WinWindowFromID(client, IDML_MAINEDIT) &&
  3109.              CurrentStatus==PROGSTATUS_EDITING)
  3110.             WinSendDlgItemMsg(client, IDML_MAINEDIT, MLM_DELETELINE, NULL, NULL);
  3111.          break;
  3112.  
  3113.       case IDA_UNDO:
  3114.          if (WinQueryFocus(HWND_DESKTOP)==WinWindowFromID(client, IDML_MAINEDIT) &&
  3115.              CurrentStatus==PROGSTATUS_EDITING)
  3116.             WinSendDlgItemMsg(client, IDML_MAINEDIT, MLM_UNDO, NULL, NULL);
  3117.          break;
  3118.  
  3119.       case IDA_KEYSHELP:
  3120.          if (hwndhelp)
  3121.             SendMsg(hwndhelp, HM_KEYS_HELP, NULL, NULL);
  3122.          break;
  3123.  
  3124.       case IDA_F2:
  3125.       case IDA_F3:
  3126.       case IDA_F4:
  3127.       case IDA_F5:
  3128.       case IDA_F6:
  3129.       case IDA_F7:
  3130.       case IDA_F8:
  3131.       case IDA_F9:
  3132.       case IDA_F10:
  3133.       case IDA_F11:
  3134.       case IDA_F12:
  3135.          if (WinQueryFocus(HWND_DESKTOP)==WinWindowFromID(client, IDML_MAINEDIT) &&
  3136.              CurrentStatus==PROGSTATUS_EDITING)
  3137.             InsertMacro(WinWindowFromID(client, IDML_MAINEDIT), CommandID-IDA_F2);
  3138.          break;
  3139.  
  3140.       case IDA_REPLY:
  3141.       case IDA_REPLYNOJOIN:
  3142.          QuoteCurrentMessage(pWindowData, FALSE,
  3143. #if 1
  3144.                              REPLYDEST_FROM,
  3145. #else
  3146.                              MSG_FindKludge(&CurrentMessage, KLUDGE_FWDFROM, NULL)?REPLYDEST_ORIG:REPLYDEST_FROM,
  3147. #endif
  3148.                              (CommandID==IDA_REPLYNOJOIN)?(QUOTE_TEXT|QUOTE_NOJOIN):QUOTE_TEXT);
  3149.          break;
  3150.  
  3151.       case IDA_REPLYNET:
  3152.       case IDA_REPLYNETNOJOIN:
  3153.          QuoteCurrentMessage(pWindowData, TRUE,
  3154. #if 1
  3155.                              REPLYDEST_FROM,
  3156. #else
  3157.                              MSG_FindKludge(&CurrentMessage, KLUDGE_FWDFROM, NULL)?REPLYDEST_ORIG:REPLYDEST_FROM,
  3158. #endif
  3159.                              (CommandID==IDA_REPLYNETNOJOIN)?(QUOTE_TEXT|QUOTE_NOJOIN):QUOTE_TEXT);
  3160.          break;
  3161.  
  3162.       case IDA_TOGGLE_CRASH:
  3163.          if (CurrentStatus==PROGSTATUS_EDITING)
  3164.          {
  3165.             CurrentHeader.ulAttrib ^= ATTRIB_CRASH;
  3166.             DisplayAttrib(CurrentHeader.ulAttrib);
  3167.          }
  3168.          break;
  3169.  
  3170.       case IDA_TOGGLE_KILL:
  3171.          if (CurrentStatus==PROGSTATUS_EDITING)
  3172.          {
  3173.             CurrentHeader.ulAttrib ^= ATTRIB_KILLSENT;
  3174.             DisplayAttrib(CurrentHeader.ulAttrib);
  3175.          }
  3176.          break;
  3177.  
  3178.       case IDA_TOGGLE_FILE:
  3179.          if (CurrentStatus==PROGSTATUS_EDITING)
  3180.          {
  3181.             CurrentHeader.ulAttrib ^= ATTRIB_FILEATTACHED;
  3182.             HandleAttachAttrib(client);
  3183.          }
  3184.          break;
  3185.  
  3186.       case IDA_TOGGLE_REQ:
  3187.          if (CurrentStatus==PROGSTATUS_EDITING)
  3188.          {
  3189.             CurrentHeader.ulAttrib ^= ATTRIB_FREQUEST;
  3190.             DisplayAttrib(CurrentHeader.ulAttrib);
  3191.          }
  3192.          break;
  3193.  
  3194.       case IDA_TOGGLE_PRIV:
  3195.          if (CurrentStatus==PROGSTATUS_EDITING)
  3196.          {
  3197.             CurrentHeader.ulAttrib ^= ATTRIB_PRIVATE;
  3198.             DisplayAttrib(CurrentHeader.ulAttrib);
  3199.          }
  3200.          break;
  3201.  
  3202.       case IDA_TOGGLE_HOLD:
  3203.          if (CurrentStatus==PROGSTATUS_EDITING)
  3204.          {
  3205.             CurrentHeader.ulAttrib ^= ATTRIB_HOLD;
  3206.             DisplayAttrib(CurrentHeader.ulAttrib);
  3207.          }
  3208.          break;
  3209.  
  3210.       case IDA_TOGGLE_DIRECT:
  3211.          if (CurrentStatus==PROGSTATUS_EDITING)
  3212.          {
  3213.             CurrentHeader.ulAttrib ^= ATTRIB_DIRECT;
  3214.             DisplayAttrib(CurrentHeader.ulAttrib);
  3215.          }
  3216.          break;
  3217.  
  3218.       case IDA_HOMEMSG:
  3219.       case IDB_HOMEMSG:
  3220.          if (CurrentStatus==PROGSTATUS_READING)
  3221.          {
  3222.             ULONG ulHome=MSG_QueryHomeMsg(&arealiste, CurrentArea);
  3223.  
  3224.             if (ulHome)
  3225.             {
  3226.                if (pWindowData->pArea)
  3227.                {
  3228.                   pWindowData->pArea->currentmessage=ulHome;
  3229.                   MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  3230.                   pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  3231.                   UpdateDisplay(FALSE, TRUE);
  3232.                }
  3233.                else
  3234.                   WinAlarm(HWND_DESKTOP, WA_ERROR);
  3235.             }
  3236.             else
  3237.                WinAlarm(HWND_DESKTOP, WA_ERROR);
  3238.          }
  3239.          break;
  3240.  
  3241.       case IDA_NEXTAREA:
  3242.       case IDB_NEXTAREA:
  3243.          {
  3244.             char *pchNextArea=NULL;
  3245.             MSGLISTPAR MsgListPar;
  3246.             MESSAGEID MessageID;
  3247.  
  3248.             MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  3249.             strcpy(MessageID.pchAreaTag, CurrentArea);
  3250.             MessageID.ulMsgID=pWindowData->ulCurrentID;
  3251.             SendMsg(client, WORKM_READ, &MessageID, NULL);
  3252.  
  3253.             if (pchNextArea=QueryNextArea(&arealiste, CurrentArea))
  3254.             {
  3255.                MSG_CloseArea(&arealiste, CurrentArea, TRUE, miscoptions.lastreadoffset, &driveremap);
  3256.                SwitchToArea(pchNextArea);
  3257.                pWindowData->ulCurrentID=MsgListPar.msgnum=CurrentHeader.ulMsgID;
  3258.                if (hwndThreadList)
  3259.                   SendMsg(hwndThreadList, TM_REREADTHREADS, &MsgListPar, NULL);
  3260.                if (hwndMsgList)
  3261.                   SendMsg(hwndMsgList, TM_REREADTHREADS, &MsgListPar, NULL);
  3262.             }
  3263.             else
  3264.                MessageBox(client, IDST_MSG_NONEXTAREA, 0, IDD_NONEXTAREA,
  3265.                           MB_OK | MB_WARNING);
  3266.          }
  3267.          break;
  3268.  
  3269.       case IDA_MARKTOGGLE:
  3270.          if (pWindowData->pArea && pWindowData->pArea->maxmessages>0)
  3271.          {
  3272.             if (IsMessageMarked(&MarkerList, CurrentArea, pWindowData->ulCurrentID, MARKFLAG_MANUAL))
  3273.             {
  3274.                UnmarkMessage(&MarkerList, CurrentArea, pWindowData->ulCurrentID, MARKFLAG_MANUAL);
  3275.                strcpy(MessageID.pchAreaTag, CurrentArea);
  3276.                MessageID.ulMsgID = pWindowData->ulCurrentID;
  3277.                SendMsg(client, WORKM_MSGUNMARKED, &MessageID, NULL);
  3278.             }
  3279.             else
  3280.             {
  3281.                MarkMessage(&MarkerList, CurrentArea, pWindowData->ulCurrentID,
  3282.                            QueryCurrent(&arealiste, CurrentArea), &CurrentHeader, NULL,
  3283.                            MARKFLAG_MANUAL, 0, 0);
  3284.                strcpy(MessageID.pchAreaTag, CurrentArea);
  3285.                MessageID.ulMsgID = pWindowData->ulCurrentID;
  3286.                SendMsg(client, WORKM_MSGMARKED, &MessageID, &CurrentHeader);
  3287.             }
  3288.          }
  3289.          break;
  3290.  
  3291.       case IDA_RXQUICK1:
  3292.       case IDA_RXQUICK2:
  3293.       case IDA_RXQUICK3:
  3294.       case IDA_RXQUICK4:
  3295.       case IDA_RXQUICK5:
  3296.       case IDA_RXQUICK6:
  3297.       case IDA_RXQUICK7:
  3298.       case IDA_RXQUICK8:
  3299.       case IDA_RXQUICK9:
  3300.       case IDA_RXQUICK10:
  3301.          StartQuickRexx(IDM_RXQUICK1 + CommandID - IDA_RXQUICK1);
  3302.          break;
  3303.  
  3304.       case IDA_BACKWIN:
  3305.          BackToWindow(pWindowData);
  3306.          break;
  3307.  
  3308.       default:
  3309. #ifdef DEBUG
  3310.          WinAlarm(HWND_DESKTOP, WA_NOTE);
  3311. #endif
  3312.          break;
  3313.    }
  3314.    return;
  3315. }
  3316.  
  3317. /*------------------------------ ProcessKeys   ------------------------------*/
  3318. /* Bearbeitet Tastendruecke Enter, Tab und BackTab                           */
  3319. /* Rueckgabewerte: TRUE, Taste behandelt                                     */
  3320. /*                 FALSE, Taste nicht behandelt                              */
  3321. /*---------------------------------------------------------------------------*/
  3322.  
  3323. static BOOL ProcessKeys(HWND client, USHORT usVK)
  3324. {
  3325.    HWND hwndFocus;
  3326.    USHORT FocusID;
  3327.    AREADEFLIST *zeiger=NULL;
  3328.  
  3329.    if (!(hwndFocus=WinQueryFocus(HWND_DESKTOP)))
  3330.       return FALSE;
  3331.  
  3332.    FocusID=WinQueryWindowUShort(hwndFocus, QWS_ID);
  3333.  
  3334.    zeiger=AM_FindArea(&arealiste, NewMessage?NewArea:CurrentArea);
  3335.  
  3336.    switch (usVK)
  3337.    {
  3338.       case VK_NEWLINE:
  3339.       case VK_ENTER:
  3340.          if (CurrentStatus != PROGSTATUS_EDITING)
  3341.             return FALSE;
  3342.          if (FocusID == IDE_TONAME)
  3343.          {
  3344.             char name[LEN_USERNAME+1];
  3345.             char FoundAddress[LEN_5DADDRESS+1];
  3346.  
  3347.             WinQueryDlgItemText(client, IDE_TONAME, LEN_USERNAME+1, name);
  3348.  
  3349.             /* Nicknames evtl. ersetzen */
  3350.             if (!LookupNickname(client, name, &NickNameList))
  3351.             {
  3352.                if (domains &&
  3353.                    zeiger->areadata.areatype == AREATYPE_NET &&
  3354.                    !ulCCSelected &&
  3355.                    !pQuickCCList &&
  3356.                    WinQueryDlgItemTextLength(client, IDE_TONAME) >0)
  3357.                {
  3358.                   /* Nodelist-Lookup */
  3359.                   if (PerformNameLookup(name, client, LOOKUP_NORMAL, name, FoundAddress))
  3360.                   {
  3361.                      FTNADDRESS tempAddr, tempAddr2;
  3362.                      char FromAddress[LEN_5DADDRESS+1];
  3363.                      int iMatch;
  3364.  
  3365.                      WinSetDlgItemText(client, IDE_TOADDRESS, FoundAddress);
  3366.                      WinQueryDlgItemText(client, IDE_FROMADDRESS, LEN_5DADDRESS+1, FromAddress);
  3367.                      StringToNetAddr(FromAddress, &tempAddr2, NULL);
  3368.                      StringToNetAddr(FoundAddress, &tempAddr, NULL);
  3369.                      iMatch = MSG_MatchAddress(&tempAddr, &userdaten, &tempAddr2);
  3370.                      if (iMatch>=0)
  3371.                         WinSetDlgItemText(client, IDE_FROMADDRESS, userdaten.address[iMatch]);
  3372.                      WinSetDlgItemText(client, IDE_TONAME, name);
  3373.                      SetFocusControl(client, IDE_SUBJTEXT);
  3374.                   }
  3375.                   else
  3376.                      SetFocusControl(client, IDE_TOADDRESS);
  3377.                }
  3378.                else
  3379.                   SetFocusControl(client, IDE_SUBJTEXT);
  3380.             }
  3381.          }
  3382.  
  3383.          if (FocusID == IDE_TOADDRESS)
  3384.          {
  3385.             char name[LEN_USERNAME+1];
  3386.  
  3387.             /* Fokuswechsel erzwingt Adress-Ergaenzung */
  3388.             SetFocusControl(client, IDE_SUBJTEXT);
  3389.  
  3390.             WinQueryDlgItemText(client, IDE_TONAME, LEN_USERNAME+1, name);
  3391.             if (!name[0]) /* noch kein Name eingegeben */
  3392.             {
  3393.                if (domains &&
  3394.                    zeiger->areadata.areatype == AREATYPE_NET &&
  3395.                    !ulCCSelected &&
  3396.                    !pQuickCCList &&
  3397.                    WinQueryDlgItemTextLength(client, IDE_TOADDRESS) >0)
  3398.                {
  3399.                   /* Nodelist-Lookup */
  3400.                   char pchAddress[LEN_5DADDRESS+1];
  3401.  
  3402.                   WinQueryDlgItemText(client, IDE_TOADDRESS, LEN_5DADDRESS+1, pchAddress);
  3403.  
  3404.                   if (PerformNodeLookup(pchAddress, client, name))
  3405.                      WinSetDlgItemText(client, IDE_TONAME, name);
  3406.                }
  3407.             }
  3408.          }
  3409.  
  3410.          if (FocusID == IDE_FROMNAME ||
  3411.              FocusID == IDE_FROMADDRESS ||
  3412.              FocusID == IDE_SUBJTEXT)
  3413.          {
  3414.              if (zeiger)
  3415.                 SetFocusControl(client, FLTLAY_QueryNextFocus(FocusID, zeiger->areadata.areatype != AREATYPE_NET));
  3416.          }
  3417.          if (FocusID == IDML_MAINEDIT)
  3418.             return FALSE;
  3419.          break;
  3420.  
  3421.       case VK_TAB:
  3422.          if (WinQueryFocus(HWND_DESKTOP)==WinWindowFromID(client, IDML_MAINEDIT) &&
  3423.              CurrentStatus==PROGSTATUS_EDITING)
  3424.             return FALSE;
  3425.          if (zeiger)
  3426.             SetFocusControl(client, FLTLAY_QueryNextFocus(FocusID, zeiger->areadata.areatype != AREATYPE_NET));
  3427.          break;
  3428.  
  3429.       case VK_BACKTAB:
  3430. #if 0
  3431.          if (WinQueryFocus(HWND_DESKTOP)==WinWindowFromID(client, IDML_MAINEDIT) &&
  3432.              CurrentStatus==PROGSTATUS_EDITING)
  3433.             return FALSE;
  3434. #endif
  3435.          if (zeiger)
  3436.             SetFocusControl(client, FLTLAY_QueryPrevFocus(FocusID, zeiger->areadata.areatype != AREATYPE_NET));
  3437.          break;
  3438.  
  3439.       default:
  3440.          return FALSE;
  3441.    }
  3442.    return TRUE;
  3443. }
  3444.  
  3445.  
  3446. /*------------------------------ SwitchToArea   -----------------------------*/
  3447. /* Neue Area oeffnen, Userdaten fuer Area uebernehmen                        */
  3448. /*---------------------------------------------------------------------------*/
  3449.  
  3450. static int SwitchToArea(char *NewArea)
  3451. {
  3452.    AREADEFLIST *zeiger=NULL;
  3453.    BOOL bError=FALSE;
  3454.    PWINDOWDATA pWindowData;
  3455.  
  3456.    pWindowData=(PWINDOWDATA) WinQueryWindowULong(client, QWL_USER);
  3457.  
  3458.    /* Area noch vorhanden ? */
  3459.    zeiger=AM_FindArea(&arealiste, NewArea);
  3460.    if (!zeiger)
  3461.    {  /* erste Area nehmen */
  3462.       zeiger=arealiste.pFirstArea;
  3463.    }
  3464.    if (zeiger)
  3465.    {
  3466.       /* Area oeffnen und Message lesen */
  3467.       strcpy(CurrentArea, zeiger->areadata.areatag);
  3468.       strcpy(CurrentAddress, zeiger->areadata.address);
  3469.       if (zeiger->areadata.username[0])
  3470.          strcpy(CurrentName, zeiger->areadata.username);
  3471.       else
  3472.          strcpy(CurrentName, userdaten.username[0]);
  3473.       if (MSG_OpenArea(&arealiste, CurrentArea, miscoptions.lastreadoffset, &driveremap))
  3474.       {
  3475.          if (zeiger != arealiste.pFirstArea)
  3476.          {
  3477.             zeiger=arealiste.pFirstArea;
  3478.             strcpy(CurrentArea, zeiger->areadata.areatag);
  3479.             strcpy(CurrentAddress, zeiger->areadata.address);
  3480.             if (zeiger->areadata.username[0])
  3481.                strcpy(CurrentName, zeiger->areadata.username);
  3482.             else
  3483.                strcpy(CurrentName, userdaten.username[0]);
  3484.             if (MSG_OpenArea(&arealiste, CurrentArea, miscoptions.lastreadoffset, &driveremap))
  3485.                bError=TRUE;
  3486.             else
  3487.             {
  3488.                pWindowData->pArea=zeiger;
  3489.                if (zeiger->maxmessages >0 && zeiger->currentmessage==0)
  3490.                   zeiger->currentmessage=1;
  3491.                MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  3492.                pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  3493.                if (CurrentStatus == PROGSTATUS_EDITING)
  3494.                {
  3495.                   SetTranslateMode(!(zeiger->areadata.ulAreaOpt & AREAOPT_HIGHASCII));
  3496.                }
  3497.                else
  3498.                   if (CurrentStatus == PROGSTATUS_READING)
  3499.                   {
  3500.                      PMSGTEMPLATE pTemplate;
  3501.  
  3502.                      WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_ENABLEHIGHLIGHT,
  3503.                                        MPFROMLONG(!generaloptions.nohighlight && !(zeiger->areadata.ulAreaOpt & AREAOPT_NOHIGHLIGHT)),
  3504.                                        NULL);
  3505.                      pTemplate = M_FindTemplate(&templatelist, &arealiste, zeiger->areadata.areatag);
  3506.                      if (pTemplate)
  3507.                         WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_SETQUOTECHAR,
  3508.                                           MPFROMCHAR(pTemplate->chQuoteChar), NULL);
  3509.                   }
  3510.             }
  3511.          }
  3512.          else
  3513.             bError=TRUE;
  3514.       }
  3515.       else
  3516.       {
  3517.          pWindowData->pArea=zeiger;
  3518.          if (zeiger->maxmessages >0 && zeiger->currentmessage==0)
  3519.             zeiger->currentmessage=1;
  3520.          MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  3521.          pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  3522.          if (CurrentStatus == PROGSTATUS_EDITING)
  3523.          {
  3524.             SetTranslateMode(!(zeiger->areadata.ulAreaOpt & AREAOPT_HIGHASCII));
  3525.          }
  3526.          else
  3527.             if (CurrentStatus == PROGSTATUS_READING)
  3528.             {
  3529.                PMSGTEMPLATE pTemplate;
  3530.                WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_ENABLEHIGHLIGHT,
  3531.                                  MPFROMLONG(!generaloptions.nohighlight && !(zeiger->areadata.ulAreaOpt & AREAOPT_NOHIGHLIGHT)),
  3532.                                  NULL);
  3533.                pTemplate = M_FindTemplate(&templatelist, &arealiste, zeiger->areadata.areatag);
  3534.                if (pTemplate)
  3535.                   WinSendDlgItemMsg(client, IDML_MAINEDIT, MSGVM_SETQUOTECHAR,
  3536.                                     MPFROMCHAR(pTemplate->chQuoteChar), NULL);
  3537.             }
  3538.       }
  3539.    }
  3540.    else
  3541.       bError=TRUE;
  3542.  
  3543.    if (bError)
  3544.    {
  3545.       /* keine Area vorhanden */
  3546.       MSG_ClearMessage(&CurrentHeader, &CurrentMessage);
  3547.       strcpy(CurrentAddress, userdaten.address[0]);
  3548.       strcpy(CurrentName, userdaten.username[0]);
  3549.       CurrentArea[0]='\0';
  3550.       pWindowData->ulCurrentID=0;
  3551.       pWindowData->pArea=NULL;
  3552.    }
  3553.    strcpy(miscoptions.lastarearead, CurrentArea);
  3554.    UpdateDisplay(TRUE, TRUE);
  3555.    return (int) bError;
  3556. }
  3557.  
  3558. /*---------------------------------------------------------------------------*/
  3559. /* Funktionsname: ProcessWorkMessages                                        */
  3560. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  3561. /* Beschreibung: Verarbeitet alle WORKM_* Messages                           */
  3562. /*                                                                           */
  3563. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  3564. /* Parameter: hwnd: Client-Window                                            */
  3565. /*            message: Work-Message                                          */
  3566. /*            mp1: Parameter 1 (meistens PMESSAGEID)                         */
  3567. /*            mp2: Parameter 2 (meist XMSG*        )                         */
  3568. /*                                                                           */
  3569. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  3570. /* Rückgabewerte: MRESULT                                                    */
  3571. /*                                                                           */
  3572. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  3573. /* Sonstiges:                                                                */
  3574. /*                                                                           */
  3575. /*---------------------------------------------------------------------------*/
  3576.  
  3577. static MRESULT ProcessWorkMessages(HWND hwnd, ULONG message, MPARAM mp1, MPARAM mp2)
  3578. {
  3579.    PWINDOWDATA pWindowData;
  3580.  
  3581.    pWindowData=(PWINDOWDATA) WinQueryWindowULong(hwnd, QWL_USER);
  3582.  
  3583.    switch(message)
  3584.    {
  3585.       case WORKM_ERROR:
  3586.          switch(MessageBox(hwnd, IDST_MSG_WORKERROR, 0, IDD_WORKERROR,
  3587.                            MB_ERROR | MB_ABORTRETRYIGNORE))
  3588.          {
  3589.             case MBID_ABORT:
  3590.                return (MRESULT) WORK_ERROR_ABORT;
  3591.  
  3592.             case MBID_RETRY:
  3593.                return (MRESULT) WORK_ERROR_RETRY;
  3594.  
  3595.             case MBID_IGNORE:
  3596.                return (MRESULT) WORK_ERROR_IGNORE;
  3597.          }
  3598.          break;
  3599.  
  3600.       case WORKM_DELETED:
  3601.          if (hwndThreadList)
  3602.             SendMsg(hwndThreadList, message, mp1, mp2);
  3603.          if (hwndMsgList)
  3604.             SendMsg(hwndMsgList, message, mp1, mp2);
  3605.          if (hwndAreaDlg)
  3606.             SendMsg(hwndAreaDlg, message, mp1, mp2);
  3607.          if (hwndFindResults)
  3608.             SendMsg(hwndFindResults, message, mp1, mp2);
  3609.          UnmarkMessage(&MarkerList, ((PMESSAGEID)mp1)->pchAreaTag,
  3610.                        ((PMESSAGEID)mp1)->ulMsgID, MARKFLAG_ALL);
  3611.          if (!stricmp(CurrentArea, ((PMESSAGEID)mp1)->pchAreaTag) &&
  3612.              CurrentStatus == PROGSTATUS_READING)
  3613.          {
  3614.             if (pWindowData->ulCurrentID == ((PMESSAGEID)mp1)->ulMsgID)
  3615.             {
  3616.                if (pWindowData->pArea->currentmessage > pWindowData->pArea->maxmessages)
  3617.                   pWindowData->pArea->currentmessage = pWindowData->pArea->maxmessages;
  3618.                if (pWindowData->pArea->maxmessages > 0)
  3619.                {
  3620.                   MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  3621.                   pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  3622.                   UpdateDisplay(FALSE, TRUE);
  3623.                }
  3624.                else
  3625.                {
  3626.                   MSG_ClearMessage(&CurrentHeader, &CurrentMessage);
  3627.                   pWindowData->ulCurrentID = 0;
  3628.                   UpdateDisplay(FALSE, TRUE);
  3629.                }
  3630.             }
  3631.             else
  3632.             {
  3633.                pWindowData->pArea->currentmessage = MSG_UidToMsgn(&arealiste, CurrentArea, pWindowData->ulCurrentID, TRUE);
  3634. #if 0
  3635.                if (pWindowData->pArea->currentmessage == pWindowData->pArea->maxmessages ||
  3636.                    pWindowData->pArea->currentmessage == 1)
  3637.                   UpdateDisplay(FALSE, TRUE);
  3638.                else
  3639. #endif
  3640.                   UpdateMsgNum(hwnd, pWindowData);
  3641.             }
  3642.          }
  3643.          break;
  3644.  
  3645.       case WORKM_MOVED:
  3646.       case WORKM_AREASCANNED:
  3647.       case WORKM_COPIED:
  3648.       case WORKM_PRINTED:
  3649.       case WORKM_EXPORTED:
  3650.       case WORKM_READ:
  3651.       case WORKM_ENABLEVIEWS:
  3652.       case WORKM_DISABLEVIEWS:
  3653.       case WORKM_AREADEFCHANGED:
  3654.       case WORKM_MARKEND:
  3655.          if (hwndThreadList)
  3656.             SendMsg(hwndThreadList, message, mp1, mp2);
  3657.          if (hwndMsgList)
  3658.             SendMsg(hwndMsgList, message, mp1, mp2);
  3659.          if (hwndAreaDlg)
  3660.             SendMsg(hwndAreaDlg, message, mp1, mp2);
  3661.          if (hwndFindResults)
  3662.             SendMsg(hwndFindResults, message, mp1, mp2);
  3663.          break;
  3664.  
  3665.       case WORKM_SWITCHACCELS:
  3666.          if (hwndThreadList)
  3667.             SendMsg(hwndThreadList, message, mp1, mp2);
  3668.          if (hwndMsgList)
  3669.             SendMsg(hwndMsgList, message, mp1, mp2);
  3670.          if (hwndAreaDlg)
  3671.             SendMsg(hwndAreaDlg, message, mp1, mp2);
  3672.          if (hwndFindResults)
  3673.             SendMsg(hwndFindResults, message, mp1, mp2);
  3674.          if (hwndKludge)
  3675.             SendMsg(hwndKludge, message, mp1, mp2);
  3676.          if (hwndNLBrowser)
  3677.             SendMsg(hwndNLBrowser, message, mp1, mp2);
  3678.          SwitchAccelsMain(frame, (ULONG) mp1);
  3679.          break;
  3680.  
  3681.       case WORKM_CHANGED:
  3682.          if (hwndThreadList)
  3683.             SendMsg(hwndThreadList, message, mp1, mp2);
  3684.          if (hwndMsgList)
  3685.             SendMsg(hwndMsgList, message, mp1, mp2);
  3686.          if (hwndAreaDlg)
  3687.             SendMsg(hwndAreaDlg, message, mp1, mp2);
  3688.          if (hwndFindResults)
  3689.             SendMsg(hwndFindResults, message, mp1, mp2);
  3690.          ChangeMarkedMessage(&MarkerList, ((PMESSAGEID)mp1)->pchAreaTag,
  3691.                              ((PMESSAGEID)mp1)->ulMsgID, (PMSGHEADER) mp2);
  3692.          break;
  3693.  
  3694.       case WORKM_STARTWORKAREA:
  3695.          OpenProgressBar(pWindowData, (PCHAR) mp1);
  3696.          break;
  3697.  
  3698.       case WORKM_PROGRESS:
  3699.          ProgressBarProgress(pWindowData, (LONG) mp1);
  3700.          break;
  3701.  
  3702.       case WORKM_ADDED:
  3703.          if (hwndThreadList)
  3704.             SendMsg(hwndThreadList, message, mp1, mp2);
  3705.          if (hwndMsgList)
  3706.             SendMsg(hwndMsgList, message, mp1, mp2);
  3707.          if (hwndAreaDlg)
  3708.             SendMsg(hwndAreaDlg, message, mp1, mp2);
  3709.          if (!stricmp(CurrentArea, ((PMESSAGEID)mp1)->pchAreaTag))
  3710.          {
  3711. #if 1
  3712.             UpdateMsgNum(hwnd, pWindowData);
  3713.             UpdateButtons(pWindowData->pArea);
  3714.             UpdateCheckField(pWindowData->pArea, pWindowData);
  3715. #else
  3716.             UpdateDisplay(TRUE, FALSE);
  3717. #endif
  3718.          }
  3719.          break;
  3720.  
  3721.       case WORKM_END:
  3722.          if (hwndThreadList)
  3723.             SendMsg(hwndThreadList, message, mp1, mp2);
  3724.          if (hwndMsgList)
  3725.             SendMsg(hwndMsgList, message, mp1, mp2);
  3726.          if (hwndAreaDlg)
  3727.             SendMsg(hwndAreaDlg, message, mp1, mp2);
  3728.          CloseProgressBar(pWindowData);
  3729.          bDoingWork=FALSE;
  3730.          WinAlarm(HWND_DESKTOP, WA_NOTE);
  3731.          break;
  3732.  
  3733.       case WORKM_REREAD:
  3734.          if (hwndThreadList)
  3735.             SendMsg(hwndThreadList, message, mp1, mp2);
  3736.          if (hwndMsgList)
  3737.             SendMsg(hwndMsgList, message, mp1, mp2);
  3738.          if (!stricmp(CurrentArea, (PCHAR) mp1))
  3739.          {
  3740.             MSG_ReadAct(&CurrentMessage, &CurrentHeader, &arealiste, CurrentArea);
  3741.             pWindowData->ulCurrentID= CurrentHeader.ulMsgID;
  3742.             UpdateDisplay(FALSE, TRUE);
  3743.          }
  3744.          break;
  3745.  
  3746.       case WORKM_SHOWMSG:
  3747.          if (hwndThreadList)
  3748.             SendMsg(hwndThreadList, message, mp1, mp2);
  3749.          if (hwndMsgList)
  3750.             SendMsg(hwndMsgList, message, mp1, mp2);
  3751.          break;
  3752.  
  3753.       case WORKM_STARTFIND:
  3754.          if (!hwndFindResults)
  3755.          {
  3756.             BOOKMARKSOPEN BMOpen={sizeof(BOOKMARKSOPEN), MARKFLAG_FIND};
  3757.  
  3758.             hwndFindResults=WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP,
  3759.                                        FindResultsProc,
  3760.                                        hmodLang, IDD_FINDRESULTS,
  3761.                                        &BMOpen);
  3762.             WinShowWindow(hwndFindResults, TRUE);
  3763.          }
  3764.          if (hwndFindResults)
  3765.             SendMsg(hwndFindResults, message, mp1, mp2);
  3766.          break;
  3767.  
  3768.       case WORKM_STOPFIND:
  3769.       case WORKM_FINDAREA:
  3770.       case WORKM_FINDPROGRESS:
  3771.       case WORKM_FINDAREAEND:
  3772.          if (hwndFindResults)
  3773.             SendMsg(hwndFindResults, message, mp1, mp2);
  3774.          break;
  3775.  
  3776.       case WORKM_MSGMARKED:
  3777.       case WORKM_MSGUNMARKED:
  3778.          if (hwndFindResults)
  3779.             SendMsg(hwndFindResults, message, mp1, mp2);
  3780.          if (((PMESSAGEID)mp1)->ulMsgID == pWindowData->ulCurrentID &&
  3781.              !stricmp(CurrentArea, ((PMESSAGEID)mp1)->pchAreaTag))
  3782.             WinSendDlgItemMsg(frame, FID_STATUSLINE, STLM_SETFIELDTEXT,
  3783.                               MPFROMLONG(pWindowData->idCheckField),
  3784.                               (message==WORKM_MSGMARKED)?MPFROMLONG(TRUE):NULL);
  3785.          break;
  3786.  
  3787.       case WORKM_TRACKMSG:
  3788.          if (hwndMsgList)
  3789.             SendMsg(hwndMsgList, message, mp1, mp2);
  3790.          break;
  3791.  
  3792.       default:
  3793.          break;
  3794.    }
  3795.    return MRFROMLONG(0);
  3796. }
  3797.  
  3798. /*---------------------------------------------------------------------------*/
  3799. /* QuickMessage, Hilfsfunktion */
  3800.  
  3801. void QuickMessage(HWND hwndOwner, char *text)
  3802. {
  3803.    WinMessageBox(HWND_DESKTOP, hwndOwner, text, "Message to you",
  3804.                  50000, MB_OK | MB_MOVEABLE);
  3805.    return;
  3806. }
  3807.  
  3808. static void ShutdownProgram(void)
  3809. {
  3810.    /* Area-Scan-Thread beenden */
  3811.    if (DoingAreaScan)
  3812.    {
  3813.       StopAreaScan=TRUE;
  3814.       DosWaitThread((PTID) &tidAreaScan, DCWW_WAIT);
  3815.    }
  3816.  
  3817.    /* Find-Thread beenden */
  3818.    if (DoingFind)
  3819.    {
  3820.       StopFind=TRUE;
  3821.       DosWaitThread((PTID) &tidFind, DCWW_WAIT);
  3822.    }
  3823.  
  3824.    /* Thread-Listen-Thread beenden */
  3825.    if (DoingInsert)
  3826.    {
  3827.       StopInsert=TRUE;
  3828.       DosWaitThread((PTID) &tidThreadList, DCWW_WAIT);
  3829.    }
  3830.  
  3831.    if (bDoingWork)
  3832.    {
  3833.       bStopWork=TRUE;
  3834.       DosWaitThread((PTID) &tidWorker, DCWW_WAIT);
  3835.    }
  3836.  
  3837.    if (hAccel1)
  3838.       WinDestroyAccelTable(hAccel1);
  3839.    if (hAccel2)
  3840.       WinDestroyAccelTable(hAccel2);
  3841.    if (hAccel3)
  3842.       WinDestroyAccelTable(hAccel3);
  3843.  
  3844.    if (hwndAreaDlg)
  3845.       WinDestroyWindow(hwndAreaDlg);
  3846.  
  3847.    if (hwndTemplates)
  3848.       WinDestroyWindow(hwndTemplates);
  3849.  
  3850.    if (hwndCCLists)
  3851.       WinDestroyWindow(hwndCCLists);
  3852.  
  3853.    if (hwndRxFolder)
  3854.       WinDestroyWindow(hwndRxFolder);
  3855.  
  3856.    if (hwndKludge)
  3857.       WinDestroyWindow(hwndKludge);
  3858.  
  3859.    if (hwndFindResults)
  3860.       WinDestroyWindow(hwndFindResults);
  3861.  
  3862.    if (hwndThreadList)
  3863.       WinDestroyWindow(hwndThreadList);
  3864.  
  3865.    if (hwndMsgList)
  3866.       WinDestroyWindow(hwndMsgList);
  3867.  
  3868.    if (hwndNLBrowser)
  3869.       WinDestroyWindow(hwndNLBrowser);
  3870.  
  3871.    return;
  3872. }
  3873.  
  3874. void StartQuickRexx(USHORT menuID)
  3875. {
  3876.    USHORT sItem=IDM_RXQUICK1;
  3877.    PRXSCRIPT pScript = scriptlist.pScripts;
  3878.  
  3879.    if (tidRexxExec)
  3880.       return;
  3881.  
  3882.    while(sItem <= IDM_RXQUICK10 && pScript)
  3883.    {
  3884.       if (pScript->ulFlags & REXXFLAG_QUICKACCESS)
  3885.       {
  3886.          if (sItem == menuID)
  3887.          {
  3888.             if (StartRexxScript(pScript->ulScriptID, NULL))
  3889.                WinAlarm(HWND_DESKTOP, WA_ERROR);
  3890.             break;
  3891.          }
  3892.          sItem++;
  3893.       }
  3894.       pScript = pScript->next;
  3895.    }
  3896.  
  3897.    return;
  3898. }
  3899.  
  3900. static void EditMenuCommands(HWND client, ULONG message)
  3901. {
  3902.    HWND hwndFokus=WinQueryFocus(HWND_DESKTOP);
  3903.    USHORT usID = WinQueryWindowUShort(hwndFokus, QWS_ID);
  3904.  
  3905.    client=client;
  3906.  
  3907.    switch(usID)
  3908.    {
  3909.       case IDE_FROMNAME:
  3910.       case IDE_FROMADDRESS:
  3911.       case IDE_TONAME:
  3912.       case IDE_TOADDRESS:
  3913.       case IDE_SUBJTEXT:
  3914.          switch (message)
  3915.          {
  3916.             case IDM_EDITCUT:
  3917.                SendMsg(hwndFokus, EM_CUT, NULL, NULL);
  3918.                break;
  3919.  
  3920.             case IDM_EDITCOPY:
  3921.                SendMsg(hwndFokus, EM_COPY, NULL, NULL);
  3922.                break;
  3923.  
  3924.             case IDM_EDITPASTE:
  3925.                SendMsg(hwndFokus, EM_PASTE, NULL, NULL);
  3926.                break;
  3927.  
  3928.             case IDM_EDITCLEAR:
  3929.                SendMsg(hwndFokus, EM_CLEAR, NULL, NULL);
  3930.                break;
  3931.          }
  3932.          break;
  3933.  
  3934.       case IDML_MAINEDIT:
  3935.          switch (message)
  3936.          {
  3937.             case IDM_EDITUNDO:
  3938.                SendMsg(hwndFokus, MLM_UNDO, NULL, NULL);
  3939.                break;
  3940.  
  3941.             case IDM_EDITCUT:
  3942.                SendMsg(hwndFokus, MLM_CUT, NULL, NULL);
  3943.                break;
  3944.  
  3945.             case IDM_EDITCOPY:
  3946.                if (CurrentStatus == PROGSTATUS_EDITING)
  3947.                {
  3948. #if 0
  3949.                   MRESULT minmax;
  3950.  
  3951.                   minmax=SendMsg(hwndFokus, MLM_QUERYSEL,
  3952.                                     MPFROMSHORT(MLFQS_MINMAXSEL),
  3953.                                     NULL);
  3954.                   if (SHORT2FROMMR(minmax)-SHORT1FROMMR(minmax))
  3955.                   {
  3956.                      /* Text ist selektiert */
  3957.                      SendMsg(hwndFokus, MLM_COPY, NULL, NULL);
  3958.                   }
  3959.                   else
  3960.                   {
  3961.                      ULONG length;
  3962.  
  3963.                      /* Text ist nicht selektiert, gesamten Text kopieren */
  3964.                      SendMsg(hwndFokus, MLM_DISABLEREFRESH, NULL, NULL);
  3965.                      length=(ULONG)SendMsg(hwndFokus,
  3966.                                      MLM_QUERYTEXTLENGTH, NULL, NULL);
  3967.                      SendMsg(hwndFokus, MLM_SETSEL, NULL, MPFROMLONG(length));
  3968.                      SendMsg(hwndFokus, MLM_COPY, NULL, NULL);
  3969.                      SendMsg(hwndFokus, MLM_SETSEL, NULL, NULL);
  3970.                      SendMsg(hwndFokus, MLM_ENABLEREFRESH, NULL, NULL);
  3971.                   }
  3972. #else
  3973.                      SendMsg(hwndFokus, MLM_COPY, NULL, NULL);
  3974. #endif
  3975.                }
  3976.                else
  3977.                   SendMsg(hwndFokus, MSGVM_COPY, NULL, NULL);
  3978.                break;
  3979.  
  3980.             case IDM_EDITPASTE:
  3981.                SendMsg(hwndFokus, MLM_PASTE, NULL, NULL);
  3982.                break;
  3983.  
  3984.             case IDM_EDITCLEAR:
  3985.                SendMsg(hwndFokus, MLM_CLEAR, NULL, NULL);
  3986.                break;
  3987.  
  3988.             case IDM_EDITDELLINE:
  3989.                SendMsg(hwndFokus, MLM_DELETELINE, NULL, NULL);
  3990.                break;
  3991.          }
  3992.          break;
  3993.    }
  3994.  
  3995.    return;
  3996. }
  3997.  
  3998. static void HandleAttachAttrib(HWND hwndClient)
  3999. {
  4000.    /* neue Attribute anzeigen */
  4001.    DisplayAttrib(CurrentHeader.ulAttrib);
  4002.  
  4003.    if (CurrentHeader.ulAttrib & ATTRIB_FILEATTACHED)
  4004.    {
  4005.       char pchTemp[LEN_SUBJECT+1];
  4006.  
  4007.       WinQueryDlgItemText(hwndClient, IDE_SUBJTEXT, LEN_SUBJECT+1, pchTemp);
  4008.       if (!pchTemp[0])
  4009.       {
  4010.          /* noch keine Files eingetragen, Dialog aufrufen */
  4011.          if (GetAttachedFiles(hwndClient, pchTemp, generaloptions.attachpath))
  4012.          {
  4013.             WinSetDlgItemText(hwndClient, IDE_SUBJTEXT, pchTemp);
  4014.          }
  4015.          else
  4016.             return;
  4017.       }
  4018.       CheckAttaches(pchTemp, hwndClient);
  4019.    }
  4020.    return;
  4021. }
  4022.  
  4023. static int QuoteCurrentMessage(PWINDOWDATA pWindowData, BOOL bDiffArea, ULONG ulReplyDest,
  4024.                                ULONG ulOptions)
  4025. {
  4026.    MESSAGEID MessageID;
  4027.    PKLUDGE pKludge;
  4028.  
  4029.    if (!pWindowData->pArea || !pWindowData->pArea->maxmessages)
  4030.       return 1;
  4031.  
  4032.    MSG_MarkRead(&arealiste, CurrentArea, 0, CurrentName, &driveremap);
  4033.    strcpy(MessageID.pchAreaTag, CurrentArea);
  4034.    MessageID.ulMsgID=pWindowData->ulCurrentID;
  4035.    SendMsg(client, WORKM_READ, &MessageID, NULL);
  4036.  
  4037.    if ((pKludge = MSG_FindKludge(&CurrentMessage, KLUDGE_AREA, NULL)) &&
  4038.        AM_FindArea(&arealiste, pKludge->pchKludgeText))
  4039.       strcpy(NewArea, pKludge->pchKludgeText);
  4040.    else
  4041.       strcpy(NewArea, CurrentArea);
  4042.  
  4043.    if (bDiffArea)
  4044.    {
  4045.       if (GetReplyArea(&CurrentMessage, NewArea))
  4046.          return 2;
  4047.    }
  4048.  
  4049.    NewMessage=TRUE;
  4050.    SendMsg(client, WORKM_DISABLEVIEWS, NULL, NULL);
  4051.    MSG_QuoteMessage(&templatelist, &CurrentMessage, &CurrentHeader, &arealiste,
  4052.                     CurrentArea, NewArea,
  4053.                     ulOptions | QUOTE_STRIPRE,
  4054.                     ulReplyDest,
  4055.                     CurrentName, CurrentAddress, &iptInitialPos);
  4056.  
  4057.    if (!stricmp(NewArea, CurrentArea))
  4058.    {
  4059.       /* ReplyTo einsetzen */
  4060.       CurrentHeader.ulReplyTo= MessageID.ulMsgID;
  4061.    }
  4062.    SwitchEditor(client, NewArea, TRUE);
  4063.    CurrentStatus = PROGSTATUS_EDITING;
  4064.    UpdateDisplay(TRUE, FALSE);
  4065.    bTemplateProcessed=FALSE;
  4066.    ulTemplateType=TPLTYPE_QUOTE;
  4067.    iptInitialPos2=0;
  4068.  
  4069.    /* Address-Matching */
  4070.    if (AM_FindArea(&arealiste, NewArea)->areadata.areatype == AREATYPE_NET)
  4071.    {
  4072.       int iMatch;
  4073.  
  4074.       iMatch=MSG_MatchAddress(&CurrentHeader.ToAddress, &userdaten, &CurrentHeader.FromAddress);
  4075.       if (iMatch>=0)
  4076.          WinSetDlgItemText(client, IDE_FROMADDRESS, userdaten.address[iMatch]);
  4077.    }
  4078.    StatusChanged(client, CurrentStatus);
  4079.    SetFocusControl(client, IDE_SUBJTEXT);
  4080.  
  4081.    return 0;
  4082. }
  4083.  
  4084. static int GetReplyArea(PFTNMESSAGE pCurrentMessage, char *pchDestArea)
  4085. {
  4086.    AREALISTPAR AreaListPar;
  4087.  
  4088.    /* Zielarea holen */
  4089.    PKLUDGE pKludge = MSG_FindKludge(pCurrentMessage, KLUDGE_AREA, NULL);
  4090.  
  4091.    AreaListPar.cb=sizeof(AREALISTPAR);
  4092.    if (pKludge && pKludge->pchKludgeText)
  4093.       AreaListPar.pchString=strdup(pKludge->pchKludgeText);
  4094.    else
  4095.       AreaListPar.pchString=NULL;
  4096.    AreaListPar.idTitle = IDST_TITLE_AL_REPLY;
  4097.    AreaListPar.ulIncludeTypes = INCLUDE_ALL;
  4098.    AreaListPar.bExtendedSel = FALSE;
  4099.    AreaListPar.bChange      = FALSE;
  4100.  
  4101.    if (WinDlgBox(HWND_DESKTOP, client,
  4102.                  AreaListProc, hmodLang,
  4103.                  IDD_AREALIST, &AreaListPar)!=DID_OK || !AreaListPar.pchString)
  4104.    {
  4105.       return 1;
  4106.    }
  4107.    else
  4108.    {
  4109.       strcpy(pchDestArea, AreaListPar.pchString);
  4110.       free(AreaListPar.pchString);
  4111.       return 0;
  4112.    }
  4113. }
  4114.  
  4115. static void ShowSecondaryWindows(BOOL bShow)
  4116. {
  4117.    if (hwndThreadList)
  4118.       WinShowWindow(hwndThreadList, bShow);
  4119.    if (hwndFindResults)
  4120.       WinShowWindow(hwndFindResults, bShow);
  4121.    if (hwndKludge)
  4122.       WinShowWindow(hwndKludge, bShow);
  4123.    if (hwndMsgList)
  4124.       WinShowWindow(hwndMsgList, bShow);
  4125.    if (hwndAreaDlg)
  4126.       WinShowWindow(hwndAreaDlg, bShow);
  4127.    if (hwndTemplates)
  4128.       WinShowWindow(hwndTemplates, bShow);
  4129.    if (hwndCCLists)
  4130.       WinShowWindow(hwndCCLists, bShow);
  4131.    if (hwndRxFolder)
  4132.       WinShowWindow(hwndRxFolder, bShow);
  4133.    if (hwndNLBrowser)
  4134.       WinShowWindow(hwndNLBrowser, bShow);
  4135.  
  4136.    return;
  4137. }
  4138.  
  4139. static BOOL SearchInMessage(HWND hwndClient, PSEARCHPAR pSearchPar)
  4140. {
  4141.    switch(CurrentStatus)
  4142.    {
  4143.       case PROGSTATUS_READING:
  4144.          return (BOOL) WinSendDlgItemMsg(hwndClient, IDML_MAINEDIT, MSGVM_FINDTEXT,
  4145.                                          pSearchPar->pchSearchText,
  4146.                               MPFROMLONG(pSearchPar->ulSearchFlags & SEARCHFLAG_CASESENSITIVE));
  4147.  
  4148.       case PROGSTATUS_EDITING:
  4149.          {
  4150.             MLE_SEARCHDATA SearchData;
  4151.             ULONG ulStyle = MLFSEARCH_SELECTMATCH;
  4152.  
  4153.             if (pSearchPar->ulSearchFlags & SEARCHFLAG_CASESENSITIVE)
  4154.                ulStyle |= MLFSEARCH_CASESENSITIVE;
  4155.  
  4156.             memset(&SearchData, 0, sizeof(SearchData));
  4157.             SearchData.cb = sizeof(SearchData);
  4158.             SearchData.pchFind = pSearchPar->pchSearchText;
  4159.             SearchData.cchFind = strlen(pSearchPar->pchSearchText);
  4160.             SearchData.iptStart = -1;
  4161.             SearchData.iptStop = -1;
  4162.  
  4163.             return (BOOL) WinSendDlgItemMsg(hwndClient, IDML_MAINEDIT, MLM_SEARCH,
  4164.                                             MPFROMLONG(ulStyle),
  4165.                                             &SearchData);
  4166.          }
  4167.  
  4168.       default:
  4169.          return FALSE;
  4170.    }
  4171. }
  4172. /*------------------------------ Programmende -------------------------------*/
  4173.