home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / utility.c < prev    next >
Text File  |  1999-02-14  |  40KB  |  1,225 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: UTILITY.C                                                          |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von: Michael Hohner            | Am: 25.08.93                    |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System:  OS/2 2.x PM                                                      |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:                                                             |
  9.  |                                                                           |
  10.  |      Hilfsfunktionen für Fleet Street                                     |
  11.  |                                                                           |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------+
  14.  | Bemerkungen:                                                              |
  15.  +---------------------------------------------------------------------------*/
  16.  
  17. /*----------------------------- Header-Dateien ------------------------------*/
  18. #pragma strings(readonly)
  19.  
  20. #define INCL_BASE
  21. #define INCL_PM
  22. #include <os2.h>
  23.  
  24. #include <stdio.h>
  25. #include <string.h>
  26. #include <stdlib.h>
  27. #include <fcntl.h>
  28. #include <share.h>
  29. #include <io.h>
  30. #include <sys\stat.h>
  31.  
  32. #include "main.h"
  33. #include "resids.h"
  34. #include "messages.h"
  35. #include "structs.h"
  36. #include "msgheader.h"
  37. #include "areaman\areaman.h"
  38. #include "dialogs.h"
  39. #include "dialogids.h"
  40. #include "utility.h"
  41. #include "setupdlg.h"
  42. #include "handlemsg\handlemsg.h"
  43. #include "util\fltutil.h"
  44. #include "util\addrcnv.h"
  45. #include "mainwindow.h"
  46.  
  47. /*--------------------------------- Defines ---------------------------------*/
  48.  
  49. #define TAB_FONT    "8.Helv"
  50. #define RGB_GREY    0x00cccccc
  51.  
  52. #define INSTANCESEM "\\SEM32\\FleetStreet"
  53.  
  54. /*---------------------------- Globale Variablen ----------------------------*/
  55.  
  56. extern HMODULE hmodLang;
  57. extern HAB anchor;
  58.  
  59. static unsigned char ReplaceTable[256][5];
  60.  
  61. /*--------------------------- Funktionsprototypen ---------------------------*/
  62.  
  63. static void WriteSeparator(FILE *outfile);
  64.  
  65. /*------------------------------ QueryCurrent   -----------------------------*/
  66. /* Gibt die aktuelle Message zurueck, im Fehlerfall 0.                       */
  67. /*---------------------------------------------------------------------------*/
  68.  
  69. int QueryCurrent(PAREALIST AreaList, PCHAR tag)
  70. {
  71.    AREADEFLIST *zeiger;
  72.  
  73.    zeiger=AM_FindArea(AreaList, tag);
  74.    if (zeiger)
  75.       return zeiger->currentmessage;
  76.    else
  77.       return 0;
  78. }
  79.  
  80. /*------------------------------ WriteEchoToss  -----------------------------*/
  81. /* Schreibt wenn noetig das Echotoss-Logfile                                 */
  82. /*---------------------------------------------------------------------------*/
  83.  
  84. int WriteEchotoss(PAREALIST AreaList, PCHAR pchEchoToss)
  85. {
  86.    FILE *fileEchoToss=NULL;
  87.    AREADEFLIST *zeiger;
  88.  
  89.    /* Altes File einlesen */
  90.    if (fileEchoToss = fopen(pchEchoToss, "r"))
  91.    {
  92.       char pchEcho[LEN_AREATAG+1];
  93.  
  94.       while (!feof(fileEchoToss))
  95.       {
  96.          if (fgets(pchEcho, sizeof(pchEcho), fileEchoToss))
  97.          {
  98.             StripWhitespace(pchEcho);
  99.             if (pchEcho[0])
  100.                if (zeiger = AM_FindArea(AreaList, pchEcho))
  101.                   zeiger->mailentered = TRUE;
  102.          }
  103.       }
  104.       fclose(fileEchoToss);
  105.       fileEchoToss=NULL;
  106.    }
  107.  
  108.    zeiger=AreaList->pFirstArea;
  109.    while(zeiger)
  110.    {
  111.       if (zeiger->mailentered &&
  112.           (zeiger->areadata.ulAreaOpt & AREAOPT_FROMCFG) &&
  113.           zeiger->areadata.areatype == AREATYPE_ECHO)
  114.       {
  115.          if (!fileEchoToss)
  116.             if ((fileEchoToss=fopen(pchEchoToss, "w"))==NULL)
  117.                return 1;
  118.          fprintf(fileEchoToss, "%s\n", zeiger->areadata.areatag);
  119.          zeiger->mailentered=FALSE;
  120.       }
  121.       zeiger=zeiger->next;
  122.    }
  123.    if (fileEchoToss)
  124.       fclose(fileEchoToss);
  125.  
  126.    return 0;
  127. }
  128.  
  129. /*------------------------------ AlreadyRunning -----------------------------*/
  130. /* Erkennt, ob Fleet Street bereits laeuft                                   */
  131. /*---------------------------------------------------------------------------*/
  132.  
  133. BOOL AlreadyRunning(void)
  134. {
  135.    HEV hev;
  136.  
  137.    switch(DosCreateEventSem(INSTANCESEM, &hev, 0, FALSE))
  138.    {
  139.       case NO_ERROR:
  140.          return FALSE; /* Sem existiert noch nicht: wir sind die ersten */
  141.  
  142.       case ERROR_DUPLICATE_NAME:
  143.          return TRUE;  /* Sem gibt es schon: wir sind nur zweiter */
  144.  
  145.       default:
  146.          return FALSE;
  147.    }
  148. }
  149.  
  150. /*-----------------------------  QueryWinPos   ------------------------------*/
  151. /* Fragt die Fensterposition eines Fensters ab                               */
  152. /*---------------------------------------------------------------------------*/
  153.  
  154. BOOL QueryWinPos(HWND hwnd, WINPOS *pWinPos)
  155. {
  156.    SWP swp;
  157.  
  158.    WinQueryWindowPos(hwnd, &swp);
  159.    if ((swp.fl & SWP_MAXIMIZE) || (swp.fl & SWP_MINIMIZE))
  160.    {
  161.       pWinPos->x=(SHORT)WinQueryWindowUShort(hwnd, QWS_XRESTORE);
  162.       pWinPos->y=(SHORT)WinQueryWindowUShort(hwnd, QWS_YRESTORE);
  163.       pWinPos->cx=(SHORT)WinQueryWindowUShort(hwnd, QWS_CXRESTORE);
  164.       pWinPos->cy=(SHORT)WinQueryWindowUShort(hwnd, QWS_CYRESTORE);
  165.    }
  166.    else
  167.    {
  168.       pWinPos->x= swp.x;
  169.       pWinPos->y= swp.y;
  170.       pWinPos->cx= swp.cx;
  171.       pWinPos->cy= swp.cy;
  172.    }
  173.    if (swp.fl & SWP_MAXIMIZE)
  174.       pWinPos->uchFlags |= WINPOS_MAX;
  175.    else
  176.       pWinPos->uchFlags &= ~WINPOS_MAX;
  177.  
  178.    if (swp.fl & SWP_MINIMIZE)
  179.       pWinPos->uchFlags |= WINPOS_MIN;
  180.    else
  181.       pWinPos->uchFlags &= ~WINPOS_MIN;
  182.  
  183.    pWinPos->uchFlags |= WINPOS_VALID;
  184.  
  185.    return TRUE;
  186. }
  187.  
  188. /*----------------------------- RestoreWinPos   -----------------------------*/
  189. /* Setzt die Fensterposition eines Fensters                                  */
  190. /*---------------------------------------------------------------------------*/
  191.  
  192. BOOL RestoreWinPos(HWND hwnd, WINPOS *pWinPos, BOOL SizeIt, BOOL bShow)
  193. {
  194.    BOOL bTemp;
  195.  
  196.    if (pWinPos->uchFlags & WINPOS_VALID)
  197.    {
  198.       ULONG flags = SWP_ZORDER | SWP_MOVE | SWP_SIZE;
  199.  
  200.       if (pWinPos->uchFlags & WINPOS_MAX)
  201.          flags |= SWP_MAXIMIZE;
  202.       else
  203.          if (pWinPos->uchFlags & WINPOS_MIN)
  204.             flags |= SWP_MINIMIZE;
  205.  
  206.       if (SizeIt)
  207.       {
  208.          bTemp=WinSetWindowPos(hwnd,
  209.                                HWND_TOP,
  210.                                pWinPos->x, pWinPos->y,
  211.                                pWinPos->cx, pWinPos->cy,
  212.                                flags);
  213.       }
  214.       else
  215.          bTemp=WinSetWindowPos(hwnd,
  216.                                HWND_TOP,
  217.                                pWinPos->x, pWinPos->y,
  218.                                0, 0,
  219.                                SWP_MOVE | SWP_ZORDER);
  220.    }
  221.  
  222.    if (bShow)
  223.       WinShowWindow(hwnd, TRUE);
  224.  
  225.    return bTemp;
  226. }
  227.  
  228. /*----------------------------- QueryForeground -----------------------------*/
  229. /* Fragt die Vordergrundfarbe eines Fensters ab                              */
  230. /*---------------------------------------------------------------------------*/
  231.  
  232. void QueryForeground(HWND hwnd, LONG *lColor)
  233. {
  234.    WinQueryPresParam(hwnd,
  235.                      PP_FOREGROUNDCOLOR,
  236.                      PP_FOREGROUNDCOLORINDEX,
  237.                      NULL,
  238.                      sizeof(LONG),
  239.                      lColor,
  240.                      QPF_ID2COLORINDEX);
  241.    return;
  242. }
  243.  
  244. void QueryControlForeground(HWND hwndParent, ULONG id, LONG *lColor)
  245. {
  246.    QueryForeground(WinWindowFromID(hwndParent, id), lColor);
  247. }
  248.  
  249. /*------------------------------ SetForeground ------------------------------*/
  250. /* Setzt die Vordergrundfarbe eines Fensters                                 */
  251. /*---------------------------------------------------------------------------*/
  252.  
  253. void SetForeground(HWND hwnd, LONG *lColor)
  254. {
  255.    WinSetPresParam(hwnd,
  256.                    PP_FOREGROUNDCOLOR,
  257.                    sizeof(LONG),
  258.                    lColor);
  259.    return;
  260. }
  261.  
  262. /*----------------------------- QueryBackground -----------------------------*/
  263. /* Fragt die Hintergrundfarbe eines Fensters ab                              */
  264. /*---------------------------------------------------------------------------*/
  265.  
  266. void QueryBackground(HWND hwnd, LONG *lColor)
  267. {
  268.    WinQueryPresParam(hwnd,
  269.                      PP_BACKGROUNDCOLOR,
  270.                      PP_BACKGROUNDCOLORINDEX,
  271.                      NULL,
  272.                      sizeof(LONG),
  273.                      lColor,
  274.                      QPF_ID2COLORINDEX);
  275.    return;
  276. }
  277.  
  278. void QueryControlBackground(HWND hwndParent, ULONG id, LONG *lColor)
  279. {
  280.    QueryBackground(WinWindowFromID(hwndParent, id), lColor);
  281. }
  282.  
  283. /*------------------------------ SetBackground ------------------------------*/
  284. /* Setzt die Hintergrundfarbe eines Fensters                                 */
  285. /*---------------------------------------------------------------------------*/
  286.  
  287. void SetBackground(HWND hwnd, LONG *lColor)
  288. {
  289.    WinSetPresParam(hwnd,
  290.                    PP_BACKGROUNDCOLOR,
  291.                    sizeof(LONG),
  292.                    lColor);
  293.    return;
  294. }
  295.  
  296. /*----------------------------- QueryFont       -----------------------------*/
  297. /* Fragt den Font eines Fensters ab                                          */
  298. /*---------------------------------------------------------------------------*/
  299.  
  300. void QueryFont(HWND hwnd, char *pchFacename)
  301. {
  302.    WinQueryPresParam(hwnd,
  303.                      PP_FONTNAMESIZE,
  304.                      0L,
  305.                      NULL,
  306.                      FACESIZE+5,
  307.                      pchFacename,
  308.                      0L);
  309.    return;
  310. }
  311.  
  312. void QueryControlFont(HWND hwndParent, ULONG id, char *pchFacename)
  313. {
  314.    QueryFont(WinWindowFromID(hwndParent, id), pchFacename);
  315. }
  316.  
  317. /*----------------------------- SetFont         -----------------------------*/
  318. /* Setzt den Font eines Fensters                                             */
  319. /*---------------------------------------------------------------------------*/
  320.  
  321. void SetFont(HWND hwnd, char *pchFacename)
  322. {
  323.    if (pchFacename[0])
  324.       WinSetPresParam(hwnd,
  325.                       PP_FONTNAMESIZE,
  326.                       strlen(pchFacename)+1,
  327.                       pchFacename);
  328.    return;
  329. }
  330.  
  331. /*------------------------------ ImportFile    ------------------------------*/
  332. /* Liesst ein Textfile und fuegt es in den Text ein                          */
  333. /* Returncodes: 0   alles OK                                                 */
  334. /*              1   Fehler beim Einlesen                                     */
  335. /*              2   Falscher Filename                                        */
  336. /*              3   Leeres File                                              */
  337. /*              4   Abbruch durch User                                       */
  338. /*---------------------------------------------------------------------------*/
  339.  
  340. #define READ_BUFFER    20000
  341. #define IMPORT_BUFFER  65000
  342.  
  343. int ImportFile(HWND hwndClient, PCHAR pchLastFileName, BOOL bConvert, BOOL bAsk)
  344. {
  345.    FILE *impfile;
  346.    int iFile;
  347.    char *textbuf;
  348.    char namebuf[LEN_PATHNAME+1];
  349.    PCHAR insptr;
  350.    int i, iDest;
  351.    IPT ipt=-1;
  352.    int rc=0;
  353.    int iRead;
  354.  
  355.    strcpy(namebuf, pchLastFileName);
  356.  
  357.    if (bAsk && GetPathname(hwndClient, namebuf)!=DID_OK)
  358.       return 4;                   /* Userabbruch */
  359.  
  360.    /* File einlesen */
  361.    iFile = _sopen(namebuf, O_RDONLY|O_BINARY, SH_DENYNO, S_IREAD|S_IWRITE);
  362.    if (iFile == -1)
  363.       return 2;
  364.  
  365.    if ((impfile = _fdopen(iFile, "rb"))==NULL)
  366.    {
  367.       /* Fehler beim Öffnen */
  368.       _close(iFile);
  369.       return 2;
  370.    }
  371.  
  372.    textbuf=calloc(1, READ_BUFFER);
  373.    DosAllocMem((PPVOID)&insptr, IMPORT_BUFFER, OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE);
  374.  
  375.    WinSendDlgItemMsg(hwndClient, IDML_MAINEDIT, MLM_DISABLEREFRESH, NULL, NULL);
  376.  
  377.    if (bConvert)
  378.    {
  379.       /* Tabelle vorbereiten */
  380.       memset(ReplaceTable, 0, sizeof(ReplaceTable));
  381.  
  382.       strcpy(ReplaceTable['á'], "a");
  383.       strcpy(ReplaceTable['â'], "a");
  384.       strcpy(ReplaceTable['ä'], "ae");
  385.       strcpy(ReplaceTable['Ä'], "Ae");
  386.       strcpy(ReplaceTable['à'], "a");
  387.       strcpy(ReplaceTable['æ'], "ae");
  388.       strcpy(ReplaceTable['Æ'], "Ae");
  389.       strcpy(ReplaceTable['α'], "a");
  390.       strcpy(ReplaceTable['Å'], "A");
  391.       strcpy(ReplaceTable['å'], "a");
  392.       strcpy(ReplaceTable['ß'], "ss");
  393.       strcpy(ReplaceTable['ç'], "c");
  394.       strcpy(ReplaceTable['Ç'], "C");
  395.       strcpy(ReplaceTable['»'], ">>");
  396.       strcpy(ReplaceTable['°'], "o");
  397.       strcpy(ReplaceTable['÷'], "/");
  398.       strcpy(ReplaceTable['·'], ".");
  399.       strcpy(ReplaceTable[''], "|");
  400.       strcpy(ReplaceTable['é'], "e");
  401.       strcpy(ReplaceTable['É'], "E");
  402.       strcpy(ReplaceTable['ê'], "e");
  403.       strcpy(ReplaceTable['ë'], "e");
  404.       strcpy(ReplaceTable['è'], "e");
  405.       strcpy(ReplaceTable['ƒ'], "f");
  406.       strcpy(ReplaceTable[''], " ");
  407.       strcpy(ReplaceTable['í'], "i");
  408.       strcpy(ReplaceTable['î'], "i");
  409.       strcpy(ReplaceTable['ï'], "i");
  410.       strcpy(ReplaceTable['ì'], "i");
  411.       strcpy(ReplaceTable['¡'], "!");
  412.       strcpy(ReplaceTable['¿'], "?");
  413.       strcpy(ReplaceTable[''], "<-");
  414.       strcpy(ReplaceTable['¬'], "-|");
  415.       strcpy(ReplaceTable['µ'], "mc");
  416.       strcpy(ReplaceTable['ñ'], "n");
  417.       strcpy(ReplaceTable['Ñ'], "N");
  418.       strcpy(ReplaceTable['ó'], "o");
  419.       strcpy(ReplaceTable['ô'], "o");
  420.       strcpy(ReplaceTable['ò'], "o");
  421.       strcpy(ReplaceTable['ö'], "oe");
  422.       strcpy(ReplaceTable['Ö'], "Oe");
  423.       strcpy(ReplaceTable['¼'], "1/4");
  424.       strcpy(ReplaceTable['½'], "1/2");
  425.       strcpy(ReplaceTable['«'], "<<");
  426.       strcpy(ReplaceTable['±'], "+-");
  427.       strcpy(ReplaceTable['£'], "UKP");
  428.       strcpy(ReplaceTable['²'], "qd");
  429.       strcpy(ReplaceTable['ⁿ'], "trp");
  430.       strcpy(ReplaceTable['ú'], "u");
  431.       strcpy(ReplaceTable['û'], "u");
  432.       strcpy(ReplaceTable['ù'], "u");
  433.       strcpy(ReplaceTable['ü'], "ue");
  434.       strcpy(ReplaceTable['Ü'], "Ue");
  435.       strcpy(ReplaceTable['ª'], "a");
  436.       strcpy(ReplaceTable['º'], "o");
  437.       strcpy(ReplaceTable['ÿ'], "y");
  438.  
  439.       for (i=180; i<=218; i++)
  440.          strcpy(ReplaceTable[i], "+");
  441.  
  442.       strcpy(ReplaceTable[179], "|");
  443.       strcpy(ReplaceTable[186], "|");
  444.       strcpy(ReplaceTable[196], "-");
  445.       strcpy(ReplaceTable[205], "-");
  446.  
  447.       strcpy(ReplaceTable[176], "#");
  448.       strcpy(ReplaceTable[177], "#");
  449.       strcpy(ReplaceTable[178], "#");
  450.       strcpy(ReplaceTable[219], "#");
  451.       strcpy(ReplaceTable[220], "#");
  452.       strcpy(ReplaceTable[221], "#");
  453.       strcpy(ReplaceTable[222], "#");
  454.       strcpy(ReplaceTable[223], "#");
  455.    }
  456.  
  457.    while (!feof(impfile))
  458.    {
  459.       if ((iRead = fread(textbuf, 1, READ_BUFFER, impfile)) > 0)
  460.       {
  461.          if (bConvert)
  462.          {
  463.             /* konvertieren */
  464.  
  465.             i=0;
  466.             iDest=0;
  467.             while((iDest < IMPORT_BUFFER) && (i < iRead))
  468.             {
  469.                if (ReplaceTable[textbuf[i]][0]==0)
  470.                   insptr[iDest++]=textbuf[i];
  471.                else
  472.                {
  473.                   strcpy(insptr+iDest, ReplaceTable[textbuf[i]]);
  474.                   iDest+=strlen(ReplaceTable[textbuf[i]]);
  475.                }
  476.                i++;
  477.             }
  478.             insptr[iDest]='\0';
  479.          }
  480.          else
  481.          {
  482.             /* unkonvertiert uebernehmen */
  483.             memcpy(insptr, textbuf, iRead);
  484.             insptr[iRead]=0;
  485.          }
  486.  
  487.          /* Portion einfuegen */
  488.          WinSendDlgItemMsg(hwndClient, IDML_MAINEDIT, MLM_FORMAT,
  489.                            MPFROMSHORT(MLFIE_CFTEXT), NULL);
  490.          WinSendDlgItemMsg(hwndClient, IDML_MAINEDIT, MLM_SETIMPORTEXPORT,
  491.                            insptr, MPFROMLONG(IMPORT_BUFFER));
  492.          WinSendDlgItemMsg(hwndClient, IDML_MAINEDIT, MLM_IMPORT,
  493.                            &ipt, MPFROMLONG(strlen(insptr)));
  494.       }
  495.       else
  496.          if (ferror(impfile))
  497.          {
  498.             rc=1;
  499.             break;
  500.          }
  501.    }
  502.    fclose(impfile);
  503.  
  504.    WinSendDlgItemMsg(hwndClient, IDML_MAINEDIT, MLM_ENABLEREFRESH, NULL, NULL);
  505.  
  506.    strcpy(pchLastFileName, namebuf);
  507.  
  508.    DosFreeMem(insptr);
  509.    free(textbuf);
  510.  
  511.    return rc;
  512. }
  513.  
  514. /*----------------------------- ExportFile      -----------------------------*/
  515. /* Exportiert eine Message in ein File                                       */
  516. /* Returncodes: 0   alles OK                                                 */
  517. /*              1   Fehler beim Schreiben                                    */
  518. /*              2   Falscher Filename                                        */
  519. /*              3   Abbruch durch User                                       */
  520. /*---------------------------------------------------------------------------*/
  521.  
  522. int ExportFile(HWND hwndOwner, PCHAR pchLastExport, BOOL bAsk, PULONG pulOptions)
  523. {
  524.    extern FTNMESSAGE CurrentMessage;
  525.    extern MSGHEADER  CurrentHeader;
  526.    extern char CurrentArea[LEN_AREATAG+1];
  527.  
  528.    if (bAsk)
  529.    {
  530.       if (GetExportName(hwndOwner, pchLastExport, pulOptions))
  531.       {
  532.          return WriteMessage(pchLastExport, &CurrentMessage, &CurrentHeader, CurrentArea,
  533.                              *pulOptions);
  534.       }
  535.       else
  536.          return 3;
  537.    }
  538.    else
  539.       return WriteMessage(pchLastExport, &CurrentMessage, &CurrentHeader, CurrentArea,
  540.                           EXPORT_WITHHEADER | EXPORT_APPEND);
  541. }
  542.  
  543. /*---------------------------- GetExportName    -----------------------------*/
  544. /* Holt Dateinamen zum Export                                                */
  545. /*---------------------------------------------------------------------------*/
  546.  
  547. BOOL GetExportName(HWND hwndOwner, PCHAR pchFileName, PULONG pulExportOptions)
  548. {
  549.    FILEDLG dlgpar;
  550.  
  551.    dlgpar.cbSize=sizeof(dlgpar);
  552.    dlgpar.fl= FDS_CENTER | FDS_CUSTOM | FDS_HELPBUTTON |
  553.               FDS_SAVEAS_DIALOG | FDS_ENABLEFILELB;
  554.    dlgpar.pszTitle="File";
  555.    dlgpar.pszOKButton="OK";
  556.    dlgpar.pfnDlgProc=ExportProc;
  557.    dlgpar.pszIType=NULL;
  558.    dlgpar.papszITypeList=NULL;
  559.    dlgpar.pszIDrive=NULL;
  560.    dlgpar.papszIDriveList=NULL;
  561.    dlgpar.hMod=hmodLang;
  562.    strcpy(dlgpar.szFullFile, pchFileName);
  563.    dlgpar.usDlgId=IDD_EXPORTFILE;
  564.    dlgpar.ulUser = *pulExportOptions;
  565.  
  566.    WinFileDlg(HWND_DESKTOP,
  567.               hwndOwner,
  568.               &dlgpar);
  569.  
  570.    if (dlgpar.lReturn != DID_OK)
  571.       return FALSE;
  572.  
  573.    strcpy(pchFileName, dlgpar.szFullFile);
  574.    *pulExportOptions = dlgpar.ulUser;
  575.  
  576.    return TRUE;
  577. }
  578.  
  579. /*----------------------------- WriteMessage    -----------------------------*/
  580. /* Schreibt eine Message auf Disk                                            */
  581. /* Returncodes: 0   alles OK                                                 */
  582. /*              1   Fehler beim Schreiben                                    */
  583. /*              2   Falscher Filename                                        */
  584. /*---------------------------------------------------------------------------*/
  585.  
  586. int WriteMessage(PCHAR pchFileName, FTNMESSAGE *Message, MSGHEADER *Header, PCHAR tag,
  587.                  ULONG ulOptions)
  588. {
  589.    FILE *outfile;
  590.    char *lastspace;
  591.    char *position;
  592.    char *linebegin;
  593.    char *runner;
  594.  
  595.    if (ulOptions & EXPORT_APPEND)
  596.       outfile=fopen(pchFileName, "a");
  597.    else
  598.       outfile=fopen(pchFileName, "w");
  599.  
  600.    if (!outfile)
  601.       return 2;
  602.  
  603.    if (ulOptions & EXPORT_WITHHEADER)
  604.    {
  605.       /* Header schreiben */
  606.       char fromtext[10]="";
  607.       char totext[10]="";
  608.       char subjtext[10]="";
  609.       char datetime[22]="";
  610.       char addrtext[LEN_5DADDRESS+1]="";
  611.       AREADEFLIST *zeiger=NULL;
  612.       extern AREALIST arealiste;
  613.  
  614.       zeiger=AM_FindArea(&arealiste, tag);
  615.       if (zeiger)
  616.       {
  617.          int i,l;
  618.  
  619.          l=strlen(zeiger->areadata.areadesc);
  620.          for (i=1; i<= (80-l-2)/2; i++)
  621.             fputc('=', outfile);
  622.          fprintf(outfile, " %s ", zeiger->areadata.areadesc);
  623.          for (; i<=(80-l-2); i++)
  624.             fputc('=', outfile);
  625.          fprintf(outfile, "\n");
  626.       }
  627.       else
  628.          WriteSeparator(outfile);
  629.  
  630.       LoadString(IDST_MW_FROM, 10, fromtext);
  631.       LoadString(IDST_MW_TO,   10, totext);
  632.       LoadString(IDST_MW_SUBJ, 10, subjtext);
  633.  
  634.       NetAddrToString(addrtext, &Header->FromAddress);
  635.       StampToString(datetime, &Header->StampWritten);
  636.       fprintf(outfile, "%8s %-33s %-15s %s\n", fromtext, Header->pchFromName, addrtext, datetime);
  637.       StampToString(datetime, &Header->StampArrived);
  638.       if (zeiger && zeiger->areadata.areatype == AREATYPE_ECHO)
  639.          addrtext[0]=0;
  640.       else
  641.          NetAddrToString(addrtext, &Header->ToAddress);
  642.       fprintf(outfile, "%8s %-33s %-15s %s\n", totext, Header->pchToName, addrtext, datetime);
  643.       fprintf(outfile, "%8s %-71s\n", subjtext, Header->pchSubject);
  644.       WriteSeparator(outfile);
  645.    }
  646.  
  647.    /* Messagetext schreiben */
  648.    position=Message->pchMessageText;
  649.    lastspace=position;
  650.    linebegin=position;
  651.  
  652.    while (*position)
  653.       switch(*position)
  654.       {
  655.          case ' ':
  656.             lastspace=position;
  657.             position++;
  658.             break;
  659.  
  660.          case '\n':
  661.             for (runner=linebegin; runner<position; runner++)
  662.                 putc(*runner, outfile);
  663.             fputc('\n', outfile);
  664.             linebegin=++position;
  665.             break;
  666.  
  667.          default:
  668.             position++;
  669.             if ((position-linebegin) > 80)
  670.             {
  671.                if (lastspace<linebegin)   /* Letztes Space vor dem Zeilenanfang */
  672.                {
  673.                   /* ueberlange Zeile schreiben */
  674.                   for (runner=linebegin; runner<position; runner++)
  675.                      putc(*runner, outfile);
  676.                   linebegin=position;
  677.                }
  678.                else
  679.                {
  680.                   /* schreiben bis zum letzten Space */
  681.                   for (runner=linebegin; runner<=lastspace; runner++)
  682.                      putc(*runner, outfile);
  683.                   linebegin=lastspace+1;
  684.                }
  685.                fputc('\n', outfile);
  686.             }
  687.             break;
  688.       }
  689.    if (position>=linebegin)
  690.       for (runner=linebegin; runner<position; runner++)
  691.          putc(*runner, outfile);
  692.  
  693.    fputc('\n', outfile);
  694.  
  695.    if (ulOptions & EXPORT_SEPARATOR)
  696.       WriteSeparator(outfile);
  697.  
  698.    fclose(outfile);
  699.    return 0;
  700. }
  701.  
  702. static void WriteSeparator(FILE *outfile)
  703. {
  704.    fprintf(outfile, "===================="
  705.                     "===================="
  706.                     "===================="
  707.                     "====================\n");
  708.    return;
  709. }
  710.  
  711.  
  712. /*----------------------------- Notify --------------------------------------*/
  713. /* Zeigt den angegebenen String in der Statuszeile an                        */
  714. /*---------------------------------------------------------------------------*/
  715.  
  716. void Notify(HWND hwndOwner, ULONG idString)
  717. {
  718.    char pchTemp[100];
  719.  
  720.    LoadString(idString, 100, pchTemp);
  721.    WinSetDlgItemText(WinQueryWindow(hwndOwner, QW_PARENT), FID_STATUSLINE, pchTemp);
  722.  
  723.    return;
  724. }
  725.  
  726. /*----------------------------- CleanupDomains  -----------------------------*/
  727. /* Löscht alle Domains                                                       */
  728. /*---------------------------------------------------------------------------*/
  729.  
  730. void CleanupDomains(PDOMAINS *ppDomains)
  731. {
  732.    PDOMAINS pTemp;
  733.  
  734.    while(*ppDomains)
  735.    {
  736.       pTemp=(*ppDomains)->next;
  737.       free(*ppDomains);
  738.       (*ppDomains)=pTemp;
  739.    }
  740.    return;
  741. }
  742.  
  743. /*-------------------------------- QueryDomain  -----------------------------*/
  744. /* Sucht ein Domain                                                          */
  745. /*---------------------------------------------------------------------------*/
  746.  
  747. PDOMAINS QueryDomain(PDOMAINS domains, char *pchDomainName)
  748. {
  749.    PDOMAINS pTemp=domains;
  750.  
  751.    while(pTemp && stricmp(pTemp->domainname, pchDomainName))
  752.    {
  753.       pTemp=pTemp->next;
  754.    }
  755.    return pTemp;
  756. }
  757.  
  758. /*---------------------------------------------------------------------------*/
  759. /* Funktionsname: StartShell                                                 */
  760. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  761. /* Beschreibung: Startet eine Command-Shell                                  */
  762. /*                                                                           */
  763. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  764. /* Parameter: -                                                              */
  765. /*                                                                           */
  766. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  767. /* Rückgabewerte: 0  OK                                                      */
  768. /*                1  Fehler                                                  */
  769. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  770. /* Sonstiges:                                                                */
  771. /*                                                                           */
  772. /*---------------------------------------------------------------------------*/
  773.  
  774. int StartShell(void)
  775. {
  776.    STARTDATA    StartData;    /* Start session data structure */
  777.    ULONG        SessID;       /* Session ID (returned) */
  778.    PID          PID;          /* Process ID (returned) */
  779.    UCHAR ObjBuf[100];         /* Object buffer */
  780.    APIRET       rc;           /* Return code */
  781.  
  782.     /*  Specify the various session start parameters  */
  783.  
  784.     StartData.Length = sizeof(STARTDATA);
  785.     StartData.Related = 0;                 /* unrelated */
  786.     StartData.FgBg = 0;                    /* Foreground */
  787.     StartData.TraceOpt = SSF_TRACEOPT_NONE;
  788.     StartData.PgmTitle = "Shell";
  789.     StartData.PgmName = NULL;              /* Default-Shell */
  790.     StartData.PgmInputs = 0;               /* keine Parameter */
  791.     StartData.TermQ = 0;
  792.     StartData.Environment = 0;
  793.     StartData.InheritOpt = SSF_INHERTOPT_SHELL; /* Environment erben */
  794.     StartData.SessionType = SSF_TYPE_WINDOWABLEVIO;
  795.     StartData.IconFile = 0;
  796.     StartData.PgmHandle = 0;
  797.     StartData.PgmControl = SSF_CONTROL_VISIBLE /*| SSF_CONTROL_MAXIMIZE*/;
  798.     StartData.InitXPos = 30;
  799.     StartData.InitYPos = 40;
  800.     StartData.InitXSize = 200;
  801.     StartData.InitYSize = 140;
  802.     StartData.Reserved = 0;
  803.     StartData.ObjectBuffer = ObjBuf;
  804.     StartData.ObjectBuffLen = 100;
  805.     rc = DosStartSession(&StartData, &SessID, &PID);
  806.  
  807.     if (rc != 0)
  808.        return 1;
  809.     else
  810.        return 0;
  811. }
  812.  
  813. /*---------------------------------------------------------------------------*/
  814. /* Funktionsname: MessageBox                                                 */
  815. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  816. /* Beschreibung: Zeigt eine Message-Box an                                   */
  817. /*                                                                           */
  818. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  819. /* Parameter: -                                                              */
  820. /*                                                                           */
  821. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  822. /* Rückgabewerte: Return-Wert v. WinMessageBox                               */
  823. /*                                                                           */
  824. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  825. /* Sonstiges:                                                                */
  826. /*                                                                           */
  827. /*---------------------------------------------------------------------------*/
  828.  
  829. USHORT MessageBox(HWND hwndOwner, ULONG ulIDMessage, ULONG ulIDTitle,
  830.                   USHORT usWinID, ULONG flStyle)
  831. {
  832.    char message[200];
  833.    char title[200];
  834.  
  835.    if (ulIDMessage)
  836.       LoadString(ulIDMessage, 200, message);
  837.  
  838.    if (ulIDTitle)
  839.       LoadString(ulIDTitle, 200, title);
  840.  
  841.    return WinMessageBox(HWND_DESKTOP, hwndOwner,
  842.                         ulIDMessage?message:NULL,
  843.                         ulIDTitle?title:NULL,
  844.                         usWinID, MB_HELP | MB_MOVEABLE | flStyle);
  845. }
  846.  
  847. /*---------------------------------------------------------------------------*/
  848. /* Funktionsname: QueryNextArea                                              */
  849. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  850. /* Beschreibung: Sucht die naechste Area mit ungel. Mail                     */
  851. /*                                                                           */
  852. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  853. /* Parameter: arealist: Liste aller Areas                                    */
  854. /*            pchCurrent: Area-Tag der aktuellen Area                        */
  855. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  856. /* Rückgabewerte: NULL  keine solche Area gefunden                           */
  857. /*                sonst  Zeiger auf Area-Tag                                 */
  858. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  859. /* Sonstiges:                                                                */
  860. /*                                                                           */
  861. /*---------------------------------------------------------------------------*/
  862.  
  863. char *QueryNextArea(PAREALIST arealist, char *pchCurrent)
  864. {
  865.    AREADEFLIST *pThisArea=AM_FindArea(arealist, pchCurrent);
  866.    AREADEFLIST *pNextArea=NULL;
  867.    extern HWND hwndAreaDlg;
  868.    extern AREALISTOPTIONS arealistoptions;
  869.  
  870.    if (pThisArea)
  871.    {
  872.       pNextArea=pThisArea->next;
  873.  
  874.       while (pNextArea != pThisArea) /* max. einmal rum */
  875.       {
  876.          if (pNextArea == NULL)
  877.             pNextArea=arealist->pFirstArea;  /* wieder von vorne suchen */
  878.          else
  879.          {
  880.             if (pNextArea->scanned &&
  881.                 !pNextArea->bLocked &&
  882.                 pNextArea->currentmessage < pNextArea->maxmessages)
  883.                return pNextArea->areadata.areatag;
  884.             else
  885.                pNextArea=pNextArea->next;
  886.          }
  887.       }
  888.    }
  889.    return NULL;
  890. }
  891.  
  892. HWND ReplaceSysMenu(HWND hwndDlg, HWND hwndPopupMenu, USHORT usSubID)
  893. {
  894.    HWND  hSysMenu, hSysSubMenu;
  895.    SHORT idSysMenu;
  896.    MENUITEM SysMenu;
  897.    MENUITEM MenuItem;
  898.  
  899.    hSysMenu = WinWindowFromID(hwndDlg, FID_SYSMENU);
  900.    idSysMenu = SHORT1FROMMR(SendMsg(hSysMenu, MM_ITEMIDFROMPOSITION, NULL, NULL));
  901.    SendMsg(hSysMenu, MM_QUERYITEM, MPFROM2SHORT(idSysMenu, FALSE),
  902.               MPFROMP(&SysMenu));
  903.    hSysSubMenu = SysMenu.hwndSubMenu;
  904.  
  905.    SysMenu.hwndSubMenu = hwndPopupMenu;
  906.    SendMsg(hSysMenu, MM_SETITEM, MPFROM2SHORT(0, FALSE),
  907.               MPFROMP(&SysMenu));
  908.  
  909.    SendMsg(hwndPopupMenu, MM_QUERYITEM, MPFROM2SHORT(usSubID, FALSE),
  910.               &MenuItem);
  911.  
  912.    MenuItem.afStyle |= MIS_SUBMENU;
  913.    MenuItem.hwndSubMenu = hSysSubMenu;
  914.    SendMsg(hwndPopupMenu, MM_SETITEM, MPFROM2SHORT(0, FALSE),
  915.               &MenuItem);
  916.    WinSetWindowUShort(hwndPopupMenu, QWS_ID, idSysMenu);
  917.    WinSetWindowULong(hwndPopupMenu, QWL_STYLE,
  918.                      WinQueryWindowULong(hSysSubMenu, QWL_STYLE));
  919.    WinSetOwner(hwndPopupMenu, hSysMenu);
  920.    WinSetParent(hwndPopupMenu, hSysMenu, FALSE);
  921.  
  922.    return hSysSubMenu;
  923. }
  924.  
  925. void ResetMenuStyle(HWND hwndPopup, HWND hwndDialog)
  926. {
  927.    ULONG ulStyle;
  928.    HWND hwndSys;
  929.  
  930.    ulStyle = WinQueryWindowULong(hwndPopup, QWL_STYLE);
  931.    ulStyle &= 0xffff0000UL;
  932.    WinSetWindowULong(hwndPopup, QWL_STYLE, ulStyle);
  933.    hwndSys = WinWindowFromID(hwndDialog, FID_SYSMENU);
  934.    WinSetOwner(hwndPopup, hwndSys);
  935.    WinSetParent(hwndPopup, hwndSys, FALSE);
  936.  
  937.    return;
  938. }
  939.  
  940. BOOL CalcClientRect(HAB hab, HWND hwndFrame, PRECTL prclResult)
  941. {
  942.    POINTL BorderSize={0, 0};
  943.  
  944.    SendMsg(hwndFrame, WM_QUERYBORDERSIZE, &BorderSize, NULL);
  945.  
  946.    WinInflateRect(hab, prclResult, -BorderSize.x, -BorderSize.y);
  947.    prclResult->yTop -= WinQuerySysValue(HWND_DESKTOP, SV_CYTITLEBAR);
  948.  
  949.    return TRUE;
  950. }
  951.  
  952. BOOL SizeToClient(HAB hab, PSWP pSwp, HWND hwndDialog, ULONG ulControlID)
  953. {
  954.    if (pSwp->fl & (SWP_SIZE|SWP_MINIMIZE|SWP_MAXIMIZE|SWP_RESTORE))
  955.    {
  956.       RECTL rectl;
  957.  
  958.       rectl.xLeft=0;
  959.       rectl.xRight=pSwp->cx;
  960.       rectl.yBottom=0;
  961.       rectl.yTop=pSwp->cy;
  962.  
  963.       CalcClientRect(hab, hwndDialog, &rectl);
  964.       WinSetWindowPos(WinWindowFromID(hwndDialog, ulControlID),
  965.                       NULLHANDLE,
  966.                       rectl.xLeft, rectl.yBottom,
  967.                       rectl.xRight-rectl.xLeft, rectl.yTop-rectl.yBottom,
  968.                       SWP_MOVE | SWP_SIZE);
  969.    }
  970.    return TRUE;
  971. }
  972.  
  973. BOOL SaveWinPos(HWND hwnd, PSWP pSwp, PWINPOS pWinPos, PBOOL pbDirty)
  974. {
  975.    UCHAR fl=WINPOS_VALID;
  976.  
  977.    if (pSwp->fl & SWP_MAXIMIZE)
  978.       fl |= WINPOS_MAX;
  979.    if (pSwp->fl & SWP_MINIMIZE)
  980.       fl |= WINPOS_MIN;
  981.  
  982.    if (pSwp->x != pWinPos->x  ||
  983.        pSwp->y != pWinPos->y  ||
  984.        pSwp->cx!= pWinPos->cx ||
  985.        pSwp->cy!= pWinPos->cy ||
  986.        fl != pWinPos->uchFlags)
  987.    {
  988.       QueryWinPos(hwnd, pWinPos);
  989.       if (pbDirty)
  990.          *pbDirty = TRUE;
  991.       return TRUE;
  992.    }
  993.    return FALSE;
  994. }
  995.  
  996. char *CreateUniqueName(ULONG ulStringID, PVOID pData,
  997.                        int (*CompareFunc)(PVOID, char*),
  998.                        ULONG ulBufferLen, char *pchBuffer)
  999. {
  1000.    int iTries=0;
  1001.  
  1002.    do
  1003.    {
  1004.       *pchBuffer=0;
  1005.       LoadString(ulStringID, ulBufferLen, pchBuffer);
  1006.  
  1007.       if (iTries)
  1008.       {
  1009.          char pchNum[20];
  1010.  
  1011.          strcat(pchBuffer, ":");
  1012.          _itoa(iTries, pchNum, 10);
  1013.          strcat(pchBuffer, pchNum);
  1014.       }
  1015.       iTries++;
  1016.    } while (CompareFunc(pData, pchBuffer));
  1017.  
  1018.    return pchBuffer;
  1019. }
  1020.  
  1021. void SetNotebookParams(HWND hwndNotebook, USHORT usTabX)
  1022. {
  1023.    SendMsg(hwndNotebook, BKM_SETDIMENSIONS,
  1024.               MPFROM2SHORT(usTabX, 25),
  1025.               MPFROMSHORT(BKA_MAJORTAB));
  1026.  
  1027.    SendMsg(hwndNotebook, BKM_SETDIMENSIONS,
  1028.               MPFROM2SHORT(usTabX, 25),
  1029.               MPFROMSHORT(BKA_MINORTAB));
  1030.  
  1031.    SendMsg(hwndNotebook, BKM_SETDIMENSIONS,
  1032.               MPFROM2SHORT(25,25),
  1033.               MPFROMSHORT(BKA_PAGEBUTTON));
  1034.  
  1035.    SendMsg(hwndNotebook, BKM_SETNOTEBOOKCOLORS,
  1036.               MPFROMLONG(RGB_GREY),
  1037.               MPFROMSHORT(BKA_BACKGROUNDPAGECOLOR));
  1038.  
  1039.    SendMsg(hwndNotebook, BKM_SETNOTEBOOKCOLORS,
  1040.               MPFROMLONG(RGB_GREY),
  1041.               MPFROMSHORT(BKA_BACKGROUNDMAJORCOLOR));
  1042.  
  1043.    SendMsg(hwndNotebook, BKM_SETNOTEBOOKCOLORS,
  1044.               MPFROMLONG(RGB_GREY),
  1045.               MPFROMSHORT(BKA_BACKGROUNDMINORCOLOR));
  1046.  
  1047.    WinSetPresParam(hwndNotebook, PP_FONTNAMESIZE, sizeof(TAB_FONT), TAB_FONT);
  1048.  
  1049.    return;
  1050. }
  1051.  
  1052. /*------------------------------- InsertOnePage -----------------------------*/
  1053. /* Fuegt eine Seite in das Notebook ein                                      */
  1054. /* Laden der Dialog-Seite aus Resourcen, Setzen des Tab-Textes, Einfuegen    */
  1055. /* der Seite.                                                                */
  1056. /*---------------------------------------------------------------------------*/
  1057.  
  1058. ULONG InsertOnePage(HWND notebook, ULONG resourceID, ULONG stringID, PFNWP dlgproc, PVOID dlgpar)
  1059. {
  1060.    HWND hwnddlg;
  1061.    ULONG pageID;
  1062.    UCHAR tabtext[50];
  1063.  
  1064.    pageID=(ULONG)SendMsg(notebook,
  1065.                             BKM_INSERTPAGE,
  1066.                             (MPARAM) NULL,
  1067.                             MPFROM2SHORT(BKA_AUTOPAGESIZE | BKA_MAJOR,
  1068.                             BKA_LAST));
  1069.  
  1070.    hwnddlg=WinLoadDlg(WinQueryWindow(notebook, QW_PARENT),
  1071.                       notebook,
  1072.                       dlgproc,
  1073.                       hmodLang,
  1074.                       resourceID,
  1075.                       dlgpar);
  1076.  
  1077.    SendMsg(notebook,
  1078.               BKM_SETPAGEWINDOWHWND,
  1079.               MPFROMLONG(pageID),
  1080.               MPFROMHWND(hwnddlg));
  1081.  
  1082.    LoadString( stringID, sizeof(tabtext), tabtext);
  1083.  
  1084.    SendMsg(notebook,
  1085.               BKM_SETTABTEXT,
  1086.               MPFROMLONG(pageID),
  1087.               (MPARAM) tabtext);
  1088.  
  1089.   return pageID;
  1090. }
  1091.  
  1092.  
  1093. BOOL SetFocus(HWND hwnd)
  1094. {
  1095.    return WinSetFocus(HWND_DESKTOP, hwnd);
  1096. }
  1097.  
  1098. BOOL SetFocusControl(HWND hwndParent, ULONG ulID)
  1099. {
  1100.    return SetFocus(WinWindowFromID(hwndParent, ulID));
  1101. }
  1102.  
  1103. MRESULT SendMsg(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  1104. {
  1105.    return WinSendMsg(hwnd, msg, mp1, mp2);
  1106. }
  1107.  
  1108. LONG LoadString(ULONG idString, LONG lBufferMax, PSZ pszBuffer)
  1109. {
  1110.    return WinLoadString(anchor, hmodLang, idString, lBufferMax, pszBuffer);
  1111. }
  1112.  
  1113. HSWITCH AddToWindowList(HWND hwndDlg)
  1114. {
  1115.    SWCNTRL SwitchCtl;
  1116.  
  1117.    SwitchCtl.hwnd=hwndDlg;
  1118.    SwitchCtl.hwndIcon=NULLHANDLE;
  1119.    SwitchCtl.hprog=NULLHANDLE;
  1120.    SwitchCtl.idProcess=0;
  1121.    SwitchCtl.idSession=0;
  1122.    SwitchCtl.uchVisibility=SWL_VISIBLE;
  1123.    SwitchCtl.fbJump=SWL_JUMPABLE;
  1124.    SwitchCtl.bProgType=PROG_PM;
  1125.    WinQueryWindowText(hwndDlg, MAXNAMEL+4, SwitchCtl.szSwtitle);
  1126.  
  1127.    return WinAddSwitchEntry(&SwitchCtl);
  1128. }
  1129.  
  1130. ULONG RemoveFromWindowList(HSWITCH hSwitch)
  1131. {
  1132.    if (hSwitch)
  1133.       return WinRemoveSwitchEntry(hSwitch);
  1134.    else
  1135.       return 0;
  1136. }
  1137.  
  1138.  
  1139. HPOINTER LoadIcon(ULONG ulIconID)
  1140. {
  1141.    return WinLoadPointer(HWND_DESKTOP, NULLHANDLE, ulIconID);
  1142. }
  1143.  
  1144. MRESULT RedirectCommand(MPARAM mp1, MPARAM mp2)
  1145. {
  1146.    extern HWND client;
  1147.  
  1148.    switch(SHORT1FROMMP(mp1))
  1149.    {
  1150.       case IDA_AREA:
  1151.       case IDA_MSGLIST:
  1152.       case IDA_THREADLIST:
  1153.       case IDA_BOOKMARKS:
  1154.       case IDA_NLBROWSER:
  1155.       case IDA_KLUDGES:
  1156. #if 0
  1157.       case IDA_CATCHUP:
  1158.       case IDA_NEXTAREA:
  1159. #endif
  1160.          return SendMsg(client, WM_COMMAND, mp1, mp2);
  1161.  
  1162.       default:
  1163.          return (MRESULT) NULL;
  1164.    }
  1165. }
  1166.  
  1167. void SwitchAccels(HWND hwndFrame, ULONG ulAccelNum)
  1168. {
  1169.    extern HACCEL hAccel3;
  1170.  
  1171.    switch(ulAccelNum)
  1172.    {
  1173.       case ACCEL_NONE:
  1174.       case ACCEL_WRITE:
  1175.          WinSetAccelTable(anchor, NULLHANDLE, hwndFrame);
  1176.          break;
  1177.  
  1178.       case ACCEL_READ:
  1179.          WinSetAccelTable(anchor, hAccel3, hwndFrame);
  1180.          break;
  1181.  
  1182.       default:
  1183.          break;
  1184.    }
  1185.    return;
  1186. }
  1187.  
  1188. void SwitchAccelsMain(HWND hwndFrame, ULONG ulAccelNum)
  1189. {
  1190.    extern HACCEL hAccel1, hAccel2;
  1191.  
  1192.    switch(ulAccelNum)
  1193.    {
  1194.       case ACCEL_NONE:
  1195.          WinSetAccelTable(anchor, NULLHANDLE, hwndFrame);
  1196.          break;
  1197.  
  1198.       case ACCEL_WRITE:
  1199.          WinSetAccelTable(anchor, hAccel2, hwndFrame);
  1200.          break;
  1201.  
  1202.       case ACCEL_READ:
  1203.          WinSetAccelTable(anchor, hAccel1, hwndFrame);
  1204.          break;
  1205.  
  1206.       default:
  1207.          break;
  1208.    }
  1209.    return;
  1210. }
  1211.  
  1212. void SetInitialAccel(HWND hwndFrame)
  1213. {
  1214.    extern int CurrentStatus;
  1215.    extern HACCEL hAccel3;
  1216.  
  1217.    if (CurrentStatus == PROGSTATUS_READING)
  1218.       WinSetAccelTable(anchor, hAccel3, hwndFrame);
  1219.  
  1220.    return;
  1221. }
  1222.  
  1223. /*-------------------------------- Modulende --------------------------------*/
  1224.  
  1225.