home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / setupdlg.c < prev    next >
C/C++ Source or Header  |  1999-01-17  |  86KB  |  2,308 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: SETUPDLG.C                                                         |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von: Michael Hohner            | Am: 01.08.93                    |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System: OS/2 2.x PM                                                       |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:                                                             |
  9.  |                                                                           |
  10.  |       Setup-Dialoge von FleetStreet                                       |
  11.  |                                                                           |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------+
  14.  | Bemerkungen:                                                              |
  15.  +---------------------------------------------------------------------------*/
  16.  
  17. /*----------------------------- Header-Dateien ------------------------------*/
  18. #pragma strings(readonly)
  19.  
  20. #define INCL_BASE
  21. #define INCL_WIN
  22. #include <os2.h>
  23. #include <string.h>
  24. #include <stdlib.h>
  25. #include <stdio.h>
  26.  
  27. #include "main.h"
  28. #include "resids.h"
  29. #include "messages.h"
  30. #include "structs.h"
  31. #include "msgheader.h"
  32. #include "areaman\areaman.h"
  33. #include "dialogs.h"
  34. #include "dialogids.h"
  35. #include "init.h"
  36. #include "setupdlg.h"
  37. #include "utility.h"
  38. #include "controls\editwin.h"
  39. #include "controls\msgviewer.h"
  40. #include "controls\clrsel.h"
  41. #include "util\fltutil.h"
  42. #include "util\addrcnv.h"
  43. #include "cfgfile_interface.h"
  44.  
  45. /*--------------------------------- Defines ---------------------------------*/
  46.  
  47. #define TAB_FONT         "8.Helv"
  48. #define RGB_GREY         0x00cccccc
  49. #define NUM_PAGES_SETUP  17
  50.  
  51. typedef struct _domainentrypar
  52. {
  53.   USHORT cb;
  54.   PDOMAINS pDomain;
  55. } DOMAINENTRYPAR;
  56.  
  57. /*---------------------------- Globale Variablen ----------------------------*/
  58.  
  59. extern HMODULE hmodLang;
  60. extern HAB anchor;
  61.  
  62. PFNWP OldContainerProc;
  63.  
  64. /*--------------------------- Funktionsprototypen ---------------------------*/
  65.  
  66. static void UpdateAdrList(HWND parent);
  67. static void UpdateNameList(HWND parent);
  68. static void InsertNotebookPages(HWND notebook, NBPAGE *Table);
  69. static MRESULT EXPENTRY DomainEntryProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  70. static MRESULT EXPENTRY ModemTypesProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  71. static MRESULT EXPENTRY AddressesProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  72. static MRESULT EXPENTRY DefOriginProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  73. static MRESULT EXPENTRY MacrosProc2(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  74. static MRESULT EXPENTRY MacrosProc3(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  75. static MRESULT EXPENTRY DomainsProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  76. static MRESULT EXPENTRY StartupProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  77. static MRESULT EXPENTRY EditorOptProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  78. static MRESULT EXPENTRY UserProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  79. static MRESULT EXPENTRY MacrosProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  80. static MRESULT EXPENTRY MsgOptProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  81. static MRESULT EXPENTRY SquishOptProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  82. static MRESULT EXPENTRY TosserPathsProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  83. static MRESULT EXPENTRY NewUserProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  84. static MRESULT EXPENTRY NewAddressProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  85. static MRESULT EXPENTRY RemapSetupProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  86. static MRESULT EXPENTRY SafetyOptProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  87. static MRESULT EXPENTRY OpenWinProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  88. static void UpdateDomains(HWND hwnd);
  89. static ULONG GetCfgType(HWND hwndDlg);
  90. static void SetCfgType(HWND hwndDlg, ULONG ulCfgType);
  91. static int ReadNewCfgFile(HWND parent, HWND hwndSetupFrame, char *pchPathName);
  92. static void RefreshModemTypeList(HWND hwndDlg, ULONG ulIdCnr, NODELISTOPT *pNodelist);
  93. static void CheckOpenWinButton(HWND hwndDlg, ULONG ulID, POPENWIN pOpenWindows, ULONG ulMask);
  94. static void QueryOpenWinButton(HWND hwndDlg, ULONG ulID, POPENWIN pOpenWindows, ULONG ulMask);
  95.  
  96. /*------------------------------ OptionsProc   ------------------------------*/
  97. /* Hauptdialog-Prozedur Optionen                                             */
  98. /* Initialisierung des Notebooks                                             */
  99. /*---------------------------------------------------------------------------*/
  100.  
  101. MRESULT EXPENTRY OptionsProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  102. {
  103.    extern WINDOWPOSITIONS windowpositions;
  104.    extern HWND hwndhelp, frame;
  105.  
  106.    static NBPAGE PageTable[NUM_PAGES_SETUP];
  107.    static HWND notebook=NULLHANDLE;
  108.    int i;
  109.    MRESULT resultbuf=0;
  110.  
  111.    switch(message)
  112.    {
  113.       case WM_INITDLG:
  114.          /* Leere Seitentabelle */
  115.          memset(PageTable, 0, sizeof(PageTable));
  116.          notebook=WinWindowFromID(parent, IDD_SETUPOPTIONS+1);
  117.  
  118.          SetNotebookParams(notebook, 110);
  119.  
  120.          /* Leere Seiten einfuegen */
  121.          InsertNotebookPages(notebook, PageTable);
  122.          /* erste Seite gleich anzeigen */
  123.          LoadPage(notebook, &(PageTable[0]), NULL);
  124.  
  125.          RestoreWinPos(parent, &windowpositions.optionspos, TRUE, TRUE);
  126.          WinAssociateHelpInstance(hwndhelp, parent);
  127.          break;
  128.  
  129.       case WM_ADJUSTFRAMEPOS:
  130.          SizeToClient(anchor, (PSWP) mp1, parent, IDD_SETUPOPTIONS+1);
  131.          break;
  132.  
  133.       case WM_QUERYTRACKINFO:
  134.          /* Default-Werte aus Original-Prozedur holen */
  135.          resultbuf=WinDefDlgProc(parent,message,mp1,mp2);
  136.  
  137.          /* Minimale Fenstergroesse einstellen */
  138.          ((PTRACKINFO)mp2)->ptlMinTrackSize.x=255;
  139.          ((PTRACKINFO)mp2)->ptlMinTrackSize.y=190;
  140.  
  141.          return resultbuf;
  142.  
  143.       case WM_CLOSE:
  144.          QueryWinPos(parent, &windowpositions.optionspos);
  145.          WinAssociateHelpInstance(hwndhelp, frame);
  146.          break;
  147.  
  148.       case WM_CONTROL:
  149.          if (SHORT1FROMMP(mp1)==IDD_SETUPOPTIONS+1)
  150.             if (SHORT2FROMMP(mp1)==BKN_PAGESELECTED)
  151.             {
  152.                /* Seitenwechsel */
  153.                int i=0;
  154.  
  155.                /* alte Seite in Seiten-Tabelle suchen */
  156.                while (i<NUM_PAGES_SETUP)
  157.                {
  158.                   if (PageTable[i].PageID == ((PPAGESELECTNOTIFY)mp2)->ulPageIdCur)
  159.                      break;
  160.                   else
  161.                      i++;
  162.                }
  163.                if (i<NUM_PAGES_SETUP && PageTable[i].resID==IDD_USERNAMES)
  164.                   SendMsg(PageTable[i].hwndPage, SUM_CHECKINPUT, NULL, NULL);
  165.  
  166.                /* neue Seite in Seiten-Tabelle suchen */
  167.                i=0;
  168.                while (i<NUM_PAGES_SETUP)
  169.                {
  170.                   if (PageTable[i].PageID == ((PPAGESELECTNOTIFY)mp2)->ulPageIdNew)
  171.                      break;
  172.                   else
  173.                      i++;
  174.                }
  175.  
  176.                /* Seite ggf. Laden */
  177.                if (i<NUM_PAGES_SETUP)
  178.                {
  179.                   if (PageTable[i].hwndPage==NULLHANDLE)
  180.                      LoadPage(notebook, &(PageTable[i]), NULL);
  181.                   if (PageTable[i].resID==IDD_SQUISHOPTIONS)
  182.                      SendMsg(PageTable[i].hwndPage, SUM_CHECKSETUP, NULL, NULL);
  183.                }
  184.             }
  185.          break;
  186.  
  187.       case SUM_REFRESHUSER:
  188.          /* Message an die Dialogseiten weiterreichen */
  189.          i=0;
  190.          while (i<NUM_PAGES_SETUP)
  191.          {
  192.           if ((PageTable[i].resID == IDD_ADDRESSES ||
  193.                PageTable[i].resID == IDD_USERNAMES ||
  194.                PageTable[i].resID == IDD_DEFAULTORIGIN) &&
  195.               PageTable[i].hwndPage)
  196.             SendMsg(PageTable[i].hwndPage, SUM_REFRESHUSER, NULL, NULL);
  197.             i++;
  198.          }
  199.          break;
  200.  
  201.       default:
  202.          break;
  203.    }
  204.    return WinDefDlgProc(parent,message,mp1,mp2);
  205. }
  206.  
  207. /*---------------------------- InsertNotebookPages --------------------------*/
  208. /* Fuegt alle Seiten in das Notebook ein, Einstellung der Darstellungs-      */
  209. /* Parameter des Notebooks                                                   */
  210. /*---------------------------------------------------------------------------*/
  211.  
  212. static const struct pagedef
  213. {
  214.    ULONG ulStringID;
  215.    ULONG resID;
  216.    PFNWP DlgProc;
  217. } PageDef[] =
  218. {
  219.    { IDST_TAB_USER,        IDD_USERNAMES,       UserProc},
  220.    { IDST_TAB_ADDRESSES,   IDD_ADDRESSES,       AddressesProc},
  221.    { IDST_TAB_DEFORIGIN,   IDD_DEFAULTORIGIN,   DefOriginProc},
  222.    { IDST_TAB_SQUISHOPT,   IDD_SQUISHOPTIONS,   SquishOptProc},
  223.    { IDST_TAB_TOSSERPATHS, IDD_TOSSERPATHS,     TosserPathsProc},
  224.    { IDST_TAB_MACROS,      IDD_MACROS1,         MacrosProc},
  225.    { IDST_TAB_MACROS2,     IDD_MACROS2,         MacrosProc2},
  226.    { IDST_TAB_MACROS3,     IDD_MACROS3,         MacrosProc3},
  227.    { IDST_TAB_DOMAINS,     IDD_DOMAINS,         DomainsProc},
  228.    { IDST_TAB_MODEMTYPES,  IDD_MODEMTYPES,      ModemTypesProc},
  229.    { IDST_TAB_MSGOPT,      IDD_MSGOPT,          MsgOptProc},
  230.    { IDST_TAB_STARTUP,     IDD_STARTUP,         StartupProc},
  231.    { IDST_TAB_EDITOROPT,   IDD_EDITOROPT,       EditorOptProc},
  232.    { IDST_TAB_SAFETY,      IDD_SAFETY,          SafetyOptProc},
  233.    { IDST_TAB_SU_OPENWIN,  IDD_SU_OPENWIN,      OpenWinProc},
  234.    { IDST_TAB_DRIVEREMAP,  IDD_DRIVEREMAP,      RemapSetupProc}
  235. };
  236.  
  237. #define NUM_INS_PAGES (sizeof(PageDef)/sizeof(PageDef[0]))
  238.  
  239. static void InsertNotebookPages(HWND notebook, NBPAGE *Table)
  240. {
  241.    int i;
  242.  
  243.    /* Leere Seiten einfuegen, Tabelle fuellen */
  244.    for (i=0; i < NUM_INS_PAGES; i++)
  245.    {
  246.       InsertEmptyPage(notebook, PageDef[i].ulStringID, &(Table[i]));
  247.       Table[i].resID=PageDef[i].resID;
  248.       Table[i].DlgProc=PageDef[i].DlgProc;
  249.    }
  250.  
  251.    return;
  252. }
  253.  
  254. /*------------------------------- InsertEmptyPage ---------------------------*/
  255. /* Fuegt eine leere Seite in das Notebook ein                                */
  256. /*---------------------------------------------------------------------------*/
  257.  
  258. void InsertEmptyPage(HWND notebook, ULONG stringID, NBPAGE *Page)
  259. {
  260.    extern HAB anchor;
  261.    UCHAR tabtext[50];
  262.  
  263.    Page->PageID=(ULONG)SendMsg(notebook, BKM_INSERTPAGE, NULL,
  264.                             MPFROM2SHORT(BKA_AUTOPAGESIZE | BKA_MAJOR,
  265.                             BKA_LAST));
  266.  
  267.    LoadString(stringID, sizeof(tabtext), tabtext);
  268.  
  269.    SendMsg(notebook,
  270.               BKM_SETTABTEXT,
  271.               MPFROMLONG(Page->PageID),
  272.               (MPARAM) tabtext);
  273.  
  274.    return;
  275. }
  276.  
  277. /*---------------------------------- LoadPage -------------------------------*/
  278. /* Laedt eine Seite aus den Ressourcen, fuegt in Notebook ein                */
  279. /*---------------------------------------------------------------------------*/
  280.  
  281. void LoadPage(HWND notebook, NBPAGE *Page, PVOID pCreateParam)
  282. {
  283.    Page->hwndPage=WinLoadDlg(WinQueryWindow(notebook, QW_PARENT),
  284.                              notebook,
  285.                              Page->DlgProc,
  286.                              hmodLang,
  287.                              Page->resID,
  288.                              pCreateParam);
  289.  
  290.    SendMsg(notebook,
  291.               BKM_SETPAGEWINDOWHWND,
  292.               MPFROMLONG(Page->PageID),
  293.               MPFROMHWND(Page->hwndPage));
  294.  
  295.    return;
  296. }
  297.  
  298. /*--------------------------------  UserProc --------------------------------*/
  299. /* Dialog-Prozedur des User-Dialogs                                          */
  300. /*---------------------------------------------------------------------------*/
  301.  
  302. static MRESULT EXPENTRY UserProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  303. {
  304.    STRINGPAR StringPar;
  305.    extern USERDATAOPT userdaten;
  306.    extern DIRTYFLAGS dirtyflags;
  307.    extern GENERALOPT generaloptions;
  308.    int i;
  309.    USHORT usSelect;
  310.  
  311.    switch(message)
  312.    {
  313.       case WM_COMMAND:
  314.          if (SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON)
  315.          {
  316.             switch (SHORT1FROMMP(mp1))
  317.             {
  318.                /* Neuer Name */
  319.                case IDD_USERNAMES+3:
  320.                   StringPar.cb=sizeof(STRINGPAR);
  321.                   StringPar.pchString=malloc(LEN_USERNAME+1);
  322.                   StringPar.pchString[0]='\0';
  323.                   if (WinDlgBox(HWND_DESKTOP,
  324.                                 parent,
  325.                                 NewUserProc,
  326.                                 hmodLang,
  327.                                 IDD_NEWUSER,
  328.                                 &StringPar)==DID_OK)
  329.                   {
  330.                      i=0;
  331.                      while (i<MAX_USERNAMES &&
  332.                             strcmp(userdaten.username[i], StringPar.pchString))
  333.                         i++;
  334.                      if (i<MAX_USERNAMES)
  335.                      {
  336.                         /* Name gibt es schon */
  337.                         WinAlarm(HWND_DESKTOP, WA_ERROR);
  338.                      }
  339.                      else
  340.                      {
  341.                         i=0;
  342.                         while(i<MAX_USERNAMES && userdaten.username[i][0])
  343.                            i++;
  344.                         if (i==MAX_USERNAMES)
  345.                            /* kann nicht vorkommen */
  346.                            WinAlarm(HWND_DESKTOP, WA_ERROR);
  347.                         else
  348.                         {
  349.                            strcpy(userdaten.username[i], StringPar.pchString);
  350.                            UpdateNameList(parent);
  351.                            dirtyflags.userdirty=TRUE;
  352.                         }
  353.                      }
  354.                   }
  355.                   free(StringPar.pchString);
  356.                   break;
  357.  
  358.                /* Name aendern */
  359.                case IDD_USERNAMES+4:
  360.                   StringPar.cb=sizeof(STRINGPAR);
  361.                   StringPar.pchString=malloc(LEN_USERNAME+1);
  362.                   usSelect=(USHORT)WinSendDlgItemMsg(parent, IDD_USERNAMES+2, LM_QUERYSELECTION,
  363.                                            MPFROMSHORT(LIT_FIRST), NULL);
  364.                   if (usSelect != LIT_NONE)
  365.                   {
  366.                      strcpy(StringPar.pchString, userdaten.username[usSelect]);
  367.                      if (WinDlgBox(HWND_DESKTOP,
  368.                                    parent,
  369.                                    NewUserProc,
  370.                                    hmodLang,
  371.                                    IDD_NEWUSER,
  372.                                    &StringPar)==DID_OK)
  373.                      {
  374.                         i=0;
  375.                         while ((i==usSelect) ||
  376.                                (i<MAX_USERNAMES && strcmp(userdaten.username[i], StringPar.pchString)))
  377.                            i++;
  378.                         if (i<MAX_USERNAMES)
  379.                         {
  380.                            /* Name gibt es schon */
  381.                            WinAlarm(HWND_DESKTOP, WA_ERROR);
  382.                         }
  383.                         else
  384.                         {
  385.                            strcpy(userdaten.username[usSelect], StringPar.pchString);
  386.                            dirtyflags.userdirty=TRUE;
  387.                            UpdateNameList(parent);
  388.                         }
  389.                      }
  390.                   }
  391.                   free(StringPar.pchString);
  392.                   break;
  393.  
  394.                /* Name loeschen */
  395.                case IDD_USERNAMES+5:
  396.                   usSelect=(USHORT)WinSendDlgItemMsg(parent, IDD_USERNAMES+2, LM_QUERYSELECTION,
  397.                                            MPFROMSHORT(LIT_FIRST), NULL);
  398.                   if (usSelect != LIT_NONE)
  399.                   {
  400.                      if (generaloptions.safety & SAFETY_CHANGESETUP)
  401.                      {
  402.                         if (MessageBox(parent, IDST_MSG_DELUNAME, IDST_TITLE_DELUNAME,
  403.                                        IDD_DELUNAME, MB_YESNO | MB_ICONQUESTION)==MBID_NO)
  404.                            break;
  405.                      }
  406.                      /* Name loeschen */
  407.                      if (usSelect==MAX_USERNAMES-1)
  408.                         userdaten.username[usSelect][0]='\0';
  409.                      else
  410.                      {
  411.                         for (i=usSelect+1; i<MAX_USERNAMES && userdaten.username[i][0]; i++)
  412.                            strcpy(userdaten.username[i-1], userdaten.username[i]);
  413.                         userdaten.username[i-1][0]='\0';
  414.                      }
  415.                      dirtyflags.userdirty=TRUE;
  416.                      UpdateNameList(parent);
  417.                   }
  418.                   break;
  419.  
  420.                /* Name default */
  421.                case IDD_USERNAMES+6:
  422.                   usSelect=(USHORT)WinSendDlgItemMsg(parent, IDD_USERNAMES+2, LM_QUERYSELECTION,
  423.                                            MPFROMSHORT(LIT_FIRST), NULL);
  424.                   if (usSelect != LIT_NONE && usSelect != 0)
  425.                   {
  426.                      char buffer[LEN_USERNAME+1];
  427.  
  428.                      strcpy(buffer, userdaten.username[0]);
  429.                      strcpy(userdaten.username[0], userdaten.username[usSelect]);
  430.                      strcpy(userdaten.username[usSelect], buffer);
  431.                      dirtyflags.userdirty=TRUE;
  432.                      UpdateNameList(parent);
  433.                   }
  434.                   break;
  435.  
  436.                default:
  437.                   break;
  438.             }
  439.          }
  440.          return (MRESULT) FALSE;
  441.  
  442.       case WM_INITDLG:
  443.       case SUM_REFRESHUSER:
  444.          UpdateNameList(parent);
  445.          break;
  446.  
  447.       default:
  448.          break;
  449.    }
  450.    return WinDefDlgProc(parent,message,mp1,mp2);
  451. }
  452. /*-----------------------------  UpdateNameList -----------------------------*/
  453. /* Usernamenliste neu fuellen                                                */
  454. /*---------------------------------------------------------------------------*/
  455.  
  456. static void UpdateNameList(HWND parent)
  457. {
  458.    HWND hwndListe=NULLHANDLE;
  459.    extern USERDATAOPT userdaten;
  460.    int i;
  461.  
  462.    hwndListe=WinWindowFromID(parent, IDD_USERNAMES+2);
  463.  
  464.    SendMsg(hwndListe, LM_DELETEALL, NULL, NULL);
  465.    /* Namens-Liste auffuellen */
  466.    for (i=0; i<MAX_USERNAMES && userdaten.username[i][0]; i++)
  467.       SendMsg(hwndListe, LM_INSERTITEM, MPFROMSHORT(LIT_END),
  468.                  (MPARAM) userdaten.username[i]);
  469.    SendMsg(hwndListe, LM_SELECTITEM, (MPARAM) 0, (MPARAM) TRUE);
  470.  
  471.    /* Keine Namen */
  472.    if (!userdaten.username[0][0])
  473.    {
  474.       WinEnableControl(parent, IDD_USERNAMES+4, FALSE);
  475.       WinEnableControl(parent, IDD_USERNAMES+5, FALSE);
  476.       WinEnableControl(parent, IDD_USERNAMES+6, FALSE);
  477.    }
  478.    else
  479.    {
  480.       WinEnableControl(parent, IDD_USERNAMES+4, TRUE);
  481.       WinEnableControl(parent, IDD_USERNAMES+5, TRUE);
  482.       WinEnableControl(parent, IDD_USERNAMES+6, TRUE);
  483.    }
  484.  
  485.    /* Namensliste voll */
  486.    if (userdaten.username[MAX_USERNAMES-1][0])
  487.       WinEnableControl(parent, IDD_USERNAMES+3, FALSE);
  488.    else
  489.       WinEnableControl(parent, IDD_USERNAMES+3, TRUE);
  490.     return;
  491. }
  492.  
  493. /*-----------------------------  NewUserProc  -------------------------------*/
  494. /* Dialog-Prozedur des Neuer-User-Dialogs                                    */
  495. /*---------------------------------------------------------------------------*/
  496.  
  497. static MRESULT EXPENTRY NewUserProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  498. {
  499.    extern WINDOWPOSITIONS windowpositions;
  500.    extern HWND hwndhelp;
  501.  
  502.    static char *EditText=NULL;
  503.  
  504.    switch(message)
  505.    {
  506.       case WM_COMMAND:
  507.          if (SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON)
  508.             if (SHORT1FROMMP(mp1)==DID_OK)
  509.                WinQueryDlgItemText(parent, IDD_NEWUSER+2,
  510.                                    LEN_USERNAME+1,
  511.                                    EditText);
  512.          break;
  513.  
  514.       case WM_INITDLG:
  515.          WinAssociateHelpInstance(hwndhelp, parent);
  516.          WinSendDlgItemMsg(parent,IDD_NEWUSER+2,
  517.                            EM_SETTEXTLIMIT,
  518.                            MPFROMSHORT(LEN_USERNAME),
  519.                            (MPARAM) NULL);
  520.          if (mp2) /* Pointer auf String f. Eingabefeld */
  521.          {
  522.             EditText= ((STRINGPAR *) mp2)->pchString;
  523.             WinSetDlgItemText(parent, IDD_NEWUSER+2,
  524.                               EditText);
  525.             if (EditText[0])
  526.                WinEnableControl(parent, DID_OK, TRUE);
  527.             else
  528.                WinEnableControl(parent, DID_OK, FALSE);
  529.          }
  530.          RestoreWinPos(parent, &(windowpositions.newuserpos), FALSE, TRUE);
  531.          break;
  532.  
  533.       case WM_CHAR:
  534.          WinEnableControl(parent, DID_OK,
  535.                           WinQueryDlgItemTextLength(parent, IDD_NEWUSER+2));
  536.          break;
  537.  
  538.       case WM_DESTROY:
  539.       case WM_CLOSE:
  540.          WinAssociateHelpInstance(hwndhelp, WinQueryWindow(parent, QW_OWNER));
  541.          QueryWinPos(parent, &(windowpositions.newuserpos));
  542.          break;
  543.  
  544.       default:
  545.          break;
  546.    }
  547.    return WinDefDlgProc(parent,message,mp1,mp2);
  548. }
  549.  
  550.  
  551. /*-------------------------------AddressesProc-------------------------------*/
  552. /* Dialog-Prozedur des Adressen-Dialogs                                      */
  553. /*---------------------------------------------------------------------------*/
  554.  
  555. static MRESULT EXPENTRY AddressesProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  556. {
  557.    STRINGPAR StringPar;
  558.    extern USERDATAOPT userdaten;
  559.    extern DIRTYFLAGS dirtyflags;
  560.    extern GENERALOPT generaloptions;
  561.    int i;
  562.    USHORT usSelect;
  563.  
  564.    switch(message)
  565.    {
  566.       case WM_COMMAND:
  567.          if (SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON)
  568.          {
  569.             switch (SHORT1FROMMP(mp1))
  570.             {
  571.                /* neue Adresse */
  572.                case IDD_ADDRESSES+3:
  573.                   StringPar.cb=sizeof(STRINGPAR);
  574.                   StringPar.pchString=malloc(LEN_5DADDRESS+1);
  575.                   StringPar.pchString[0]='\0';
  576.                   if (WinDlgBox(HWND_DESKTOP,
  577.                                 parent,
  578.                                 NewAddressProc,
  579.                                 hmodLang,
  580.                                 IDD_NEWADDRESS,
  581.                                 &StringPar)==DID_OK)
  582.                   {
  583.                      i=0;
  584.                      while (i<MAX_ADDRESSES &&
  585.                             strcmp(userdaten.address[i], StringPar.pchString))
  586.                         i++;
  587.                      if (i<MAX_ADDRESSES)
  588.                      {
  589.                         /* Adresse gibt es schon */
  590.                         WinAlarm(HWND_DESKTOP, WA_ERROR);
  591.                      }
  592.                      else
  593.                      {
  594.                         i=0;
  595.                         while(i<MAX_ADDRESSES && userdaten.address[i][0])
  596.                            i++;
  597.                         if (i==MAX_ADDRESSES)
  598.                            /* kann nicht vorkommen */
  599.                            WinAlarm(HWND_DESKTOP, WA_ERROR);
  600.                         else
  601.                         {
  602.                            strcpy(userdaten.address[i], StringPar.pchString);
  603.                            UpdateAdrList(parent);
  604.                            dirtyflags.userdirty=TRUE;
  605.                         }
  606.                      }
  607.                   }
  608.                   free(StringPar.pchString);
  609.                   break;
  610.  
  611.                /* Adresse aendern */
  612.                case IDD_ADDRESSES+4:
  613.                   StringPar.cb=sizeof(STRINGPAR);
  614.                   StringPar.pchString=malloc(LEN_5DADDRESS+1);
  615.                   usSelect=(USHORT)WinSendDlgItemMsg(parent, IDD_ADDRESSES+2, LM_QUERYSELECTION,
  616.                                            MPFROMSHORT(LIT_FIRST), NULL);
  617.                   if (usSelect != LIT_NONE)
  618.                   {
  619.                      strcpy(StringPar.pchString, userdaten.address[usSelect]);
  620.                      if (WinDlgBox(HWND_DESKTOP,
  621.                                    parent,
  622.                                    NewAddressProc,
  623.                                    hmodLang,
  624.                                    IDD_NEWADDRESS,
  625.                                    &StringPar)==DID_OK)
  626.                      {
  627.                         i=0;
  628.                         while ((i==usSelect) ||
  629.                                (i<MAX_ADDRESSES && strcmp(userdaten.address[i], StringPar.pchString)))
  630.                            i++;
  631.                         if (i<MAX_ADDRESSES)
  632.                         {
  633.                            /* Adresse gibt es schon */
  634.                            WinAlarm(HWND_DESKTOP, WA_ERROR);
  635.                         }
  636.                         else
  637.                         {
  638.                            strcpy(userdaten.address[usSelect], StringPar.pchString);
  639.                            dirtyflags.userdirty=TRUE;
  640.                            UpdateAdrList(parent);
  641.                         }
  642.                      }
  643.                   }
  644.                   free(StringPar.pchString);
  645.                   break;
  646.  
  647.                /* Adresse loeschen */
  648.                case IDD_ADDRESSES+5:
  649.                   usSelect=(USHORT)WinSendDlgItemMsg(parent, IDD_ADDRESSES+2, LM_QUERYSELECTION,
  650.                                            MPFROMSHORT(LIT_FIRST), NULL);
  651.                   if (usSelect != LIT_NONE)
  652.                   {
  653.                      if (generaloptions.safety & SAFETY_CHANGESETUP)
  654.                      {
  655.                         if (MessageBox(parent, IDST_MSG_DELADDRESS, IDST_TITLE_DELADDRESS,
  656.                                        IDD_DELADDRESS, MB_YESNO | MB_ICONQUESTION)==MBID_NO)
  657.                            break;
  658.                      }
  659.                      /* Adresse loeschen */
  660.                      if (usSelect==MAX_ADDRESSES-1)
  661.                         userdaten.address[usSelect][0]='\0';
  662.                      else
  663.                      {
  664.                         for (i=usSelect+1; i<MAX_ADDRESSES && userdaten.address[i][0]; i++)
  665.                            strcpy(userdaten.address[i-1], userdaten.address[i]);
  666.                         userdaten.address[i-1][0]='\0';
  667.                      }
  668.                      dirtyflags.userdirty=TRUE;
  669.                      UpdateAdrList(parent);
  670.                   }
  671.                   break;
  672.  
  673.                /* Adresse default */
  674.                case IDD_ADDRESSES+6:
  675.                   usSelect=(USHORT)WinSendDlgItemMsg(parent, IDD_ADDRESSES+2, LM_QUERYSELECTION,
  676.                                            MPFROMSHORT(LIT_FIRST), NULL);
  677.                   if (usSelect != LIT_NONE && usSelect != 0)
  678.                   {
  679.                      char buffer[LEN_5DADDRESS+1];
  680.  
  681.                      strcpy(buffer, userdaten.address[0]);
  682.                      strcpy(userdaten.address[0], userdaten.address[usSelect]);
  683.                      strcpy(userdaten.address[usSelect], buffer);
  684.                      dirtyflags.userdirty=TRUE;
  685.                      UpdateAdrList(parent);
  686.                   }
  687.                   break;
  688.  
  689.                default:
  690.                   break;
  691.             }
  692.          }
  693.          return (MRESULT) FALSE;
  694.  
  695.       case WM_INITDLG:
  696.       case SUM_REFRESHUSER:
  697.          UpdateAdrList(parent);
  698.          break;
  699.  
  700.       default:
  701.          break;
  702.    }
  703.    return WinDefDlgProc(parent,message,mp1,mp2);
  704. }
  705. /*------------------------------ UpdateAdrList ------------------------------*/
  706. /* Adressliste   neu fuellen                                                 */
  707. /*---------------------------------------------------------------------------*/
  708.  
  709. static void UpdateAdrList(HWND parent)
  710. {
  711.    extern USERDATAOPT userdaten;
  712.    HWND hwndList=NULLHANDLE;
  713.    int i;
  714.  
  715.    hwndList=WinWindowFromID(parent, IDD_ADDRESSES+2);
  716.    SendMsg(hwndList, LM_DELETEALL, NULL, NULL);
  717.    /* Address-Liste auffuellen */
  718.    for (i=0; i<MAX_ADDRESSES && userdaten.address[i][0]; i++)
  719.       SendMsg(hwndList, LM_INSERTITEM, MPFROMSHORT(LIT_END),
  720.                  (MPARAM) userdaten.address[i]);
  721.    SendMsg(hwndList, LM_SELECTITEM, (MPARAM) 0, (MPARAM) TRUE);
  722.  
  723.    /* Keine Adressen */
  724.    if (!userdaten.address[0][0])
  725.    {
  726.       WinEnableControl(parent, IDD_ADDRESSES+4, FALSE);
  727.       WinEnableControl(parent, IDD_ADDRESSES+5, FALSE);
  728.       WinEnableControl(parent, IDD_ADDRESSES+6, FALSE);
  729.    }
  730.    else
  731.    {
  732.       WinEnableControl(parent, IDD_ADDRESSES+4, TRUE);
  733.       WinEnableControl(parent, IDD_ADDRESSES+5, TRUE);
  734.       WinEnableControl(parent, IDD_ADDRESSES+6, TRUE);
  735.    }
  736.  
  737.    /* Adressliste voll */
  738.    if (userdaten.address[MAX_ADDRESSES-1][0])
  739.       WinEnableControl(parent, IDD_ADDRESSES+3, FALSE);
  740.    else
  741.       WinEnableControl(parent, IDD_ADDRESSES+3, TRUE);
  742.    return;
  743. }
  744.  
  745. /*----------------------------- NewAddressProc ------------------------------*/
  746. /* Dialog-Prozedur des Neue-Adresse-Dialogs                                  */
  747. /*---------------------------------------------------------------------------*/
  748.  
  749. static MRESULT EXPENTRY NewAddressProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  750. {
  751.    extern WINDOWPOSITIONS windowpositions;
  752.    extern HWND hwndhelp;
  753.  
  754.    static char *EditText=NULL;
  755.  
  756.    switch(message)
  757.    {
  758.       case WM_COMMAND:
  759.          if (SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON)
  760.             if (SHORT1FROMMP(mp1)==DID_OK)
  761.                WinQueryDlgItemText(parent, IDD_NEWADDRESS+2,
  762.                                    LEN_5DADDRESS+1,
  763.                                    EditText);
  764.          break;
  765.  
  766.       case WM_INITDLG:
  767.          WinAssociateHelpInstance(hwndhelp, parent);
  768.          WinSendDlgItemMsg(parent, IDD_NEWADDRESS+2,
  769.                            EM_SETTEXTLIMIT,
  770.                            MPFROMSHORT(LEN_5DADDRESS),
  771.                            (MPARAM) NULL);
  772.          if (mp2) /* Pointer auf String f. Eingabefeld */
  773.          {
  774.             EditText= ((STRINGPAR *) mp2)->pchString;
  775.             WinSetDlgItemText(parent, IDD_NEWADDRESS+2,
  776.                               EditText);
  777.             if (EditText[0])
  778.                WinEnableControl(parent, DID_OK, TRUE);
  779.             else
  780.                WinEnableControl(parent, DID_OK, FALSE);
  781.          }
  782.          RestoreWinPos(parent, &windowpositions.newaddresspos, FALSE, TRUE);
  783.          break;
  784.  
  785.       case WM_CHAR:
  786.          WinEnableControl(parent, DID_OK,
  787.                           WinQueryDlgItemTextLength(parent, IDD_NEWADDRESS+2));
  788.          break;
  789.  
  790.       case WM_CONTROL:
  791.          if (SHORT1FROMMP(mp1)==IDD_NEWADDRESS+2)
  792.             if (SHORT2FROMMP(mp1)==EN_KILLFOCUS)
  793.             {
  794.                FTNADDRESS NetAddr;
  795.                char pchTemp[LEN_5DADDRESS+1];
  796.  
  797.                WinQueryDlgItemText(parent, SHORT1FROMMP(mp1),
  798.                                    LEN_5DADDRESS+1, pchTemp);
  799.                StringToNetAddr(pchTemp, &NetAddr, NULL);
  800.                NetAddrToString(pchTemp, &NetAddr);
  801.                WinSetDlgItemText(parent, SHORT1FROMMP(mp1), pchTemp);
  802.             }
  803.          break;
  804.  
  805.       case WM_DESTROY:
  806.       case WM_CLOSE:
  807.          WinAssociateHelpInstance(hwndhelp, WinQueryWindow(parent, QW_OWNER));
  808.          QueryWinPos(parent, &windowpositions.newaddresspos);
  809.          break;
  810.  
  811.       default:
  812.          break;
  813.    }
  814.    return WinDefDlgProc(parent,message,mp1,mp2);
  815. }
  816.  
  817. /*----------------------------- DefOriginProc -------------------------------*/
  818. /* Dialog-Prozedur des Default-Origin-Dialogs                                */
  819. /*---------------------------------------------------------------------------*/
  820.  
  821. static MRESULT EXPENTRY DefOriginProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  822. {
  823.    extern USERDATAOPT userdaten;
  824.    extern DIRTYFLAGS dirtyflags;
  825.    char pchOBuffer[LEN_ORIGIN+1];
  826.  
  827.    switch(message)
  828.    {
  829.       case WM_INITDLG:
  830.       case SUM_REFRESHUSER:
  831.          WinSendDlgItemMsg(parent, IDD_DEFAULTORIGIN+2,
  832.                            EM_SETTEXTLIMIT,
  833.                            MPFROMSHORT(LEN_ORIGIN),
  834.                            (MPARAM) NULL);
  835.          WinSetDlgItemText(parent, IDD_DEFAULTORIGIN+2,
  836.                            userdaten.defaultorigin);
  837.          break;
  838.  
  839.       case WM_CLOSE:
  840.       case WM_DESTROY:
  841.          WinQueryDlgItemText(parent, IDD_DEFAULTORIGIN+2, LEN_ORIGIN+1, pchOBuffer);
  842.          if (strcmp(pchOBuffer, userdaten.defaultorigin))
  843.          {
  844.             strcpy(userdaten.defaultorigin, pchOBuffer);
  845.             dirtyflags.userdirty=TRUE;
  846.          }
  847.          break;
  848.  
  849.       case WM_COMMAND:
  850.          return (MRESULT) FALSE;
  851.  
  852.       default:
  853.          break;
  854.    }
  855.    return WinDefDlgProc(parent, message, mp1, mp2);
  856. }
  857.  
  858. /*-----------------------------  MacrosProc  --------------------------------*/
  859. /* Dialog-Prozedur des Macro-Dialogs #1                                      */
  860. /*---------------------------------------------------------------------------*/
  861.  
  862. static MRESULT EXPENTRY MacrosProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  863. {
  864.    int i;
  865.    extern MACROTABLEOPT macrotable;
  866.    extern DIRTYFLAGS dirtyflags;
  867.  
  868.    switch(message)
  869.    {
  870.       case WM_COMMAND:
  871.          return (MRESULT) FALSE;
  872.  
  873.       case WM_INITDLG:
  874.          /* Feldlaengen */
  875.          for (i=3; i<=6; i++)
  876.          {
  877.             WinSendDlgItemMsg(parent, IDD_MACROS1+i,
  878.                               MLM_SETTEXTLIMIT,
  879.                               MPFROMSHORT(LEN_MACRO),
  880.                               (MPARAM) NULL);
  881.             WinSetDlgItemText(parent, IDD_MACROS1+i,
  882.                               macrotable.macrotext[i-3]);
  883.          }
  884.          break;
  885.  
  886.       case WM_CLOSE:
  887.       case WM_DESTROY:
  888.          for (i=3; i<=6; i++)
  889.          {
  890.             char pchTemp[LEN_MACRO+1];
  891.  
  892.             WinQueryDlgItemText(parent, IDD_MACROS1+i,
  893.                                 LEN_MACRO+1, pchTemp);
  894.             if (strcmp(pchTemp, macrotable.macrotext[i-3]))
  895.             {
  896.                strcpy(macrotable.macrotext[i-3], pchTemp);
  897.                dirtyflags.macrosdirty=TRUE;
  898.             }
  899.          }
  900.          break;
  901.  
  902.       default:
  903.          break;
  904.    }
  905.    return WinDefDlgProc(parent,message,mp1,mp2);
  906. }
  907.  
  908. /*-----------------------------  MacrosProc2 --------------------------------*/
  909. /* Dialog-Prozedur des Macro-Dialogs #2                                      */
  910. /*---------------------------------------------------------------------------*/
  911.  
  912. static MRESULT EXPENTRY MacrosProc2(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  913. {
  914.    int i;
  915.    extern MACROTABLEOPT macrotable;
  916.    extern DIRTYFLAGS dirtyflags;
  917.  
  918.    switch(message)
  919.    {
  920.       case WM_COMMAND:
  921.          return (MRESULT) FALSE;
  922.  
  923.       case WM_INITDLG:
  924.          /* Feldlaengen */
  925.          for (i=3; i<=6; i++)
  926.          {
  927.             WinSendDlgItemMsg(parent, IDD_MACROS2+i,
  928.                               MLM_SETTEXTLIMIT,
  929.                               MPFROMSHORT(LEN_MACRO),
  930.                               (MPARAM) NULL);
  931.             WinSetDlgItemText(parent, IDD_MACROS2+i,
  932.                               macrotable.macrotext[i+1]);
  933.          }
  934.          break;
  935.  
  936.       case WM_CLOSE:
  937.       case WM_DESTROY:
  938.          for (i=3; i<=6; i++)
  939.          {
  940.             char pchTemp[LEN_MACRO+1];
  941.  
  942.             WinQueryDlgItemText(parent, IDD_MACROS2+i,
  943.                                 LEN_MACRO+1, pchTemp);
  944.             if (strcmp(pchTemp, macrotable.macrotext[i+1]))
  945.             {
  946.                strcpy(macrotable.macrotext[i+1], pchTemp);
  947.                dirtyflags.macrosdirty=TRUE;
  948.             }
  949.          }
  950.          break;
  951.  
  952.       default:
  953.          break;
  954.    }
  955.    return WinDefDlgProc(parent,message,mp1,mp2);
  956. }
  957.  
  958. /*-----------------------------  MacrosProc3 --------------------------------*/
  959. /* Dialog-Prozedur des Macro-Dialogs #3                                      */
  960. /*---------------------------------------------------------------------------*/
  961.  
  962. static MRESULT EXPENTRY MacrosProc3(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  963. {
  964.    int i;
  965.    extern MACROTABLEOPT macrotable;
  966.    extern DIRTYFLAGS dirtyflags;
  967.  
  968.    switch(message)
  969.    {
  970.       case WM_COMMAND:
  971.          return (MRESULT) FALSE;
  972.  
  973.       case WM_INITDLG:
  974.          /* Feldlaengen */
  975.          for (i=3; i<=5; i++)
  976.          {
  977.             WinSendDlgItemMsg(parent, IDD_MACROS3+i,
  978.                               MLM_SETTEXTLIMIT,
  979.                               MPFROMSHORT(LEN_MACRO),
  980.                               (MPARAM) NULL);
  981.             WinSetDlgItemText(parent, IDD_MACROS3+i,
  982.                               macrotable.macrotext[i+5]);
  983.          }
  984.          break;
  985.  
  986.       case WM_CLOSE:
  987.       case WM_DESTROY:
  988.          for (i=3; i<=5; i++)
  989.          {
  990.             char pchTemp[LEN_MACRO+1];
  991.  
  992.             WinQueryDlgItemText(parent, IDD_MACROS3+i,
  993.                                 LEN_MACRO+1, pchTemp);
  994.             if (strcmp(pchTemp, macrotable.macrotext[i+5]))
  995.             {
  996.                strcpy(macrotable.macrotext[i+5], pchTemp);
  997.                dirtyflags.macrosdirty=TRUE;
  998.             }
  999.          }
  1000.          break;
  1001.  
  1002.       default:
  1003.          break;
  1004.    }
  1005.    return WinDefDlgProc(parent,message,mp1,mp2);
  1006. }
  1007.  
  1008. /*-------------------------- DomainsProc ------------------------------------*/
  1009. /* Domain-Setup                                                              */
  1010. /*---------------------------------------------------------------------------*/
  1011.  
  1012. static MRESULT EXPENTRY DomainsProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  1013. {
  1014.    extern PDOMAINS domains;
  1015.    extern DIRTYFLAGS dirtyflags;
  1016.    PDOMAINS pDomains, pTemp;
  1017.    DOMAINENTRYPAR DomainEntryPar;
  1018.    extern GENERALOPT generaloptions;
  1019.    SHORT sItem;
  1020.    char pchTemp[LEN_DOMAIN+1];
  1021.  
  1022.    switch(message)
  1023.    {
  1024.       case WM_INITDLG:
  1025.          /* Listbox mit Domains fuellen */
  1026.          UpdateDomains(parent);
  1027.          break;
  1028.  
  1029.       case WM_COMMAND:
  1030.          if (SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON)
  1031.          {
  1032.             switch (SHORT1FROMMP(mp1))
  1033.             {
  1034.                /* Change-Button */
  1035.                case IDD_DOMAINS+5:
  1036.                   sItem=(SHORT)WinSendDlgItemMsg(parent, IDD_DOMAINS+3, LM_QUERYSELECTION,
  1037.                                           MPFROMSHORT(LIT_FIRST), NULL);
  1038.                   WinSendDlgItemMsg(parent, IDD_DOMAINS+3, LM_QUERYITEMTEXT,
  1039.                                     MPFROM2SHORT(sItem, LEN_DOMAIN+1), pchTemp);
  1040.                   DomainEntryPar.cb=sizeof(DOMAINENTRYPAR);
  1041.                   DomainEntryPar.pDomain=QueryDomain(domains, pchTemp);
  1042.                   if (WinDlgBox(HWND_DESKTOP, parent, DomainEntryProc,
  1043.                                 hmodLang, IDD_DOMAINENTRY, &DomainEntryPar)==DID_OK)
  1044.                   {
  1045.                      UpdateDomains(parent);
  1046.                      dirtyflags.domainsdirty=TRUE;
  1047.                   }
  1048.                   break;
  1049.  
  1050.                /* Add-Button */
  1051.                case IDD_DOMAINS+4:
  1052.                   pTemp=malloc(sizeof(DOMAINS));
  1053.                   memset(pTemp, 0, sizeof(DOMAINS));
  1054.                   DomainEntryPar.cb=sizeof(DOMAINENTRYPAR);
  1055.                   DomainEntryPar.pDomain=pTemp;
  1056.                   if (WinDlgBox(HWND_DESKTOP, parent, DomainEntryProc,
  1057.                                 hmodLang, IDD_DOMAINENTRY, &DomainEntryPar)==DID_OK)
  1058.                   {
  1059.                      pDomains=domains;
  1060.                      domains=pTemp;
  1061.                      pTemp->next=pDomains;
  1062.                      UpdateDomains(parent);
  1063.                      dirtyflags.domainsdirty=TRUE;
  1064.                   }
  1065.                   else
  1066.                      free(pTemp);
  1067.                   break;
  1068.  
  1069.                /* Delete-Button */
  1070.                case IDD_DOMAINS+6:
  1071.                   if (generaloptions.safety )
  1072.                   {
  1073.                      if (MessageBox(parent, IDST_MSG_DELDOMAIN, IDST_TITLE_DELDOMAIN,
  1074.                                     IDD_DELDOMAIN, MB_YESNO | MB_QUERY | MB_DEFBUTTON2)!=MBID_YES)
  1075.                         break;
  1076.                   }
  1077.                   sItem=(SHORT)WinSendDlgItemMsg(parent, IDD_DOMAINS+3, LM_QUERYSELECTION,
  1078.                                           MPFROMSHORT(LIT_FIRST), NULL);
  1079.                   WinSendDlgItemMsg(parent, IDD_DOMAINS+3, LM_QUERYITEMTEXT,
  1080.                                     MPFROM2SHORT(sItem, LEN_DOMAIN+1), pchTemp);
  1081.                   pTemp=domains;
  1082.                   pDomains=domains;
  1083.                   while(pTemp && stricmp(pchTemp, pTemp->domainname))
  1084.                   {
  1085.                      pDomains=pTemp;
  1086.                      pTemp=pTemp->next;
  1087.                   }
  1088.                   if (pTemp)
  1089.                   {
  1090.                      if (pTemp != domains)
  1091.                         pDomains->next=pTemp->next;
  1092.                      else
  1093.                         domains=pTemp->next;
  1094.                      free(pTemp);
  1095.                      UpdateDomains(parent);
  1096.                      dirtyflags.domainsdirty=TRUE;
  1097.                   }
  1098.                   else
  1099.                      WinAlarm(HWND_DESKTOP, WA_ERROR);
  1100.                   break;
  1101.  
  1102.                default:
  1103.                   break;
  1104.             }
  1105.          }
  1106.          return (MRESULT) FALSE;
  1107.  
  1108.       case WM_CONTROL:
  1109.          if (SHORT1FROMMP(mp1)==IDD_DOMAINS+3)
  1110.             if (SHORT2FROMMP(mp1)==LN_ENTER)
  1111.                SendMsg(parent, WM_COMMAND, MPFROMSHORT(IDD_DOMAINS+5),
  1112.                           MPFROMSHORT(CMDSRC_PUSHBUTTON));
  1113.          break;
  1114.  
  1115.       case WM_CLOSE:
  1116.       case WM_DESTROY:
  1117.          break;
  1118.  
  1119.       default:
  1120.          break;
  1121.    }
  1122.    return WinDefDlgProc(parent,message,mp1,mp2);
  1123. }
  1124.  
  1125.  
  1126. /*-------------------------- DomainEntryProc --------------------------------*/
  1127. /* Eingabe-Prozedur f. Domain-Eintrag                                        */
  1128. /*---------------------------------------------------------------------------*/
  1129.  
  1130. static MRESULT EXPENTRY DomainEntryProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  1131. {
  1132.    extern HWND hwndhelp;
  1133.    extern PDOMAINS domains;
  1134.    extern WINDOWPOSITIONS windowpositions;
  1135.    char pchTemp[LEN_DOMAIN+1];
  1136.    static DOMAINENTRYPAR *DomainEntryPar;
  1137.    PDOMAINS pTemp;
  1138.  
  1139.    switch(message)
  1140.    {
  1141.       case WM_INITDLG:
  1142.          DomainEntryPar=(DOMAINENTRYPAR *) mp2;
  1143.          WinAssociateHelpInstance(hwndhelp, parent);
  1144.          WinSubclassWindow(WinWindowFromID(parent, IDD_DOMAINENTRY+4),
  1145.                            FileEntryProc);
  1146.          WinSubclassWindow(WinWindowFromID(parent, IDD_DOMAINENTRY+6),
  1147.                            FileEntryProc);
  1148.          /* Feldlaengen */
  1149.          WinSendDlgItemMsg(parent, IDD_DOMAINENTRY+2,
  1150.                            EM_SETTEXTLIMIT,
  1151.                            MPFROMSHORT(LEN_DOMAIN),
  1152.                            NULL);
  1153.          WinSendDlgItemMsg(parent, IDD_DOMAINENTRY+4,
  1154.                            EM_SETTEXTLIMIT,
  1155.                            MPFROMSHORT(LEN_PATHNAME),
  1156.                            NULL);
  1157.          WinSendDlgItemMsg(parent, IDD_DOMAINENTRY+6,
  1158.                            EM_SETTEXTLIMIT,
  1159.                            MPFROMSHORT(LEN_PATHNAME),
  1160.                            NULL);
  1161.  
  1162.          WinSetDlgItemText(parent, IDD_DOMAINENTRY+2, DomainEntryPar->pDomain->domainname);
  1163.          WinSetDlgItemText(parent, IDD_DOMAINENTRY+4, DomainEntryPar->pDomain->indexfile);
  1164.          WinSetDlgItemText(parent, IDD_DOMAINENTRY+6, DomainEntryPar->pDomain->nodelistfile);
  1165.          if (DomainEntryPar->pDomain->domainname[0])
  1166.             WinEnableControl(parent, DID_OK, TRUE);
  1167.          RestoreWinPos(parent, &windowpositions.domainentrypos, FALSE, TRUE);
  1168.          break;
  1169.  
  1170.       case WM_CONTROL:
  1171.          if (SHORT1FROMMP(mp1)==IDD_DOMAINENTRY+2)
  1172.             if (SHORT2FROMMP(mp1)==EN_CHANGE)
  1173.                if (WinQueryDlgItemTextLength(parent, IDD_DOMAINENTRY+2))
  1174.                   WinEnableControl(parent, DID_OK, TRUE);
  1175.                else
  1176.                   WinEnableControl(parent, DID_OK, FALSE);
  1177.          break;
  1178.  
  1179.  
  1180.       case WM_COMMAND:
  1181.          if (SHORT1FROMMP(mp1)==DID_OK)
  1182.          {
  1183.             WinQueryDlgItemText(parent, IDD_DOMAINENTRY+2, LEN_DOMAIN+1, pchTemp);
  1184.             pTemp=QueryDomain(domains, pchTemp);
  1185.             if (!pTemp || (pTemp == DomainEntryPar->pDomain))
  1186.             {
  1187.                strcpy(DomainEntryPar->pDomain->domainname, pchTemp);
  1188.                WinQueryDlgItemText(parent, IDD_DOMAINENTRY+4, LEN_PATHNAME+1,
  1189.                                    DomainEntryPar->pDomain->indexfile);
  1190.                WinQueryDlgItemText(parent, IDD_DOMAINENTRY+6, LEN_PATHNAME+1,
  1191.                                    DomainEntryPar->pDomain->nodelistfile);
  1192.             }
  1193.             else
  1194.             {
  1195.                MessageBox(parent, IDST_MSG_HAVEDOMAIN, 0, IDD_HAVEDOMAIN,
  1196.                           MB_OK | MB_ERROR);
  1197.                return (MRESULT) FALSE;
  1198.             }
  1199.          }
  1200.          break;
  1201.  
  1202.       case WM_CLOSE:
  1203.       case WM_DESTROY:
  1204.          QueryWinPos(parent, &windowpositions.domainentrypos);
  1205.          WinAssociateHelpInstance(hwndhelp, WinQueryWindow(parent, QW_OWNER));
  1206.          break;
  1207.  
  1208.       default:
  1209.          break;
  1210.    }
  1211.    return WinDefDlgProc(parent,message,mp1,mp2);
  1212. }
  1213.  
  1214. /*------------------------------ UpdateDomains ------------------------------*/
  1215. /* Füllt die Listbox mit den Domains neu                                     */
  1216. /*---------------------------------------------------------------------------*/
  1217.  
  1218. static void UpdateDomains(HWND hwnd)
  1219. {
  1220.    PDOMAINS pDomains;
  1221.    extern PDOMAINS domains;
  1222.  
  1223.    WinSendDlgItemMsg(hwnd, IDD_DOMAINS+3, LM_DELETEALL, NULL, NULL);
  1224.  
  1225.    pDomains=domains;
  1226.    while (pDomains)
  1227.    {
  1228.       WinInsertLboxItem(WinWindowFromID(hwnd, IDD_DOMAINS+3), LIT_SORTASCENDING,
  1229.                         pDomains->domainname);
  1230.       pDomains=pDomains->next;
  1231.    }
  1232.  
  1233.    if (domains)  /* ueberhaupt Domains da? */
  1234.    {
  1235.       WinSendDlgItemMsg(hwnd, IDD_DOMAINS+3, LM_SELECTITEM, MPFROMSHORT(0), MPFROMSHORT(TRUE));
  1236.       WinEnableControl(hwnd, IDD_DOMAINS+5, TRUE);
  1237.       WinEnableControl(hwnd, IDD_DOMAINS+6, TRUE);
  1238.    }
  1239.    else
  1240.    {
  1241.       WinEnableControl(hwnd, IDD_DOMAINS+5, FALSE);
  1242.       WinEnableControl(hwnd, IDD_DOMAINS+6, FALSE);
  1243.    }
  1244.    return;
  1245. }
  1246.  
  1247. /*-------------------------- ModemTypesProc  --------------------------------*/
  1248. /* Eingabe-Prozedur f. Modem-Typen                                           */
  1249. /*---------------------------------------------------------------------------*/
  1250.  
  1251. typedef struct
  1252. {
  1253.    MINIRECORDCORE RecordCore;
  1254.    ULONG ulNum;
  1255.    PCHAR pchDesc;
  1256. } MODEMTYPERECORD, *PMODEMTYPERECORD;
  1257.  
  1258. static MRESULT EXPENTRY ModemTypesProc(HWND hwnd, ULONG message, MPARAM mp1, MPARAM mp2)
  1259. {
  1260.    extern NODELISTOPT nodelist;
  1261.    extern DIRTYFLAGS dirtyflags;
  1262.    PFIELDINFO pFirstField, pField;
  1263.    static char pchTitleBit[50];
  1264.    static char pchTitleByte[50];
  1265.    static char pchTitleDesc[50];
  1266.    CNRINFO cnrinfo;
  1267.  
  1268.    switch(message)
  1269.    {
  1270.       case WM_INITDLG:
  1271.          /* Strings */
  1272.          LoadString(IDST_MT_BIT, sizeof(pchTitleBit), pchTitleBit);
  1273.          LoadString(IDST_MT_BYTE, sizeof(pchTitleByte), pchTitleByte);
  1274.          LoadString(IDST_MT_DESC, sizeof(pchTitleDesc), pchTitleDesc);
  1275.  
  1276.          /* Eingabe-Feld */
  1277.          WinSendDlgItemMsg(hwnd, IDD_MODEMTYPES+7, EM_SETTEXTLIMIT,
  1278.                            MPFROMSHORT(LEN_MODEMTYPE), NULL);
  1279.  
  1280.          /* Checkboxen */
  1281.          if (nodelist.ulOptions & MODEMFLAGS_BYTETYPE)
  1282.             WinCheckButton(hwnd, IDD_MODEMTYPES+5, TRUE);
  1283.          else
  1284.             WinCheckButton(hwnd, IDD_MODEMTYPES+4, TRUE);
  1285.  
  1286.          /* Container-Beschriftung */
  1287.          pFirstField = WinSendDlgItemMsg(hwnd, IDD_MODEMTYPES+3,
  1288.                                          CM_ALLOCDETAILFIELDINFO,
  1289.                                          MPFROMSHORT(2), NULL);
  1290.          pField = pFirstField;
  1291.          if (pField)
  1292.          {
  1293.             FIELDINFOINSERT InfoInsert;
  1294.  
  1295.             /* Nummern-Feld */
  1296.             pField->cb = sizeof(FIELDINFO);
  1297.             pField->flData = CFA_ULONG | CFA_SEPARATOR | CFA_HORZSEPARATOR | CFA_RIGHT;
  1298.             pField->flTitle = CFA_FITITLEREADONLY | CFA_CENTER;
  1299.             if (nodelist.ulOptions & MODEMFLAGS_BYTETYPE)
  1300.                pField->pTitleData = pchTitleByte;
  1301.             else
  1302.                pField->pTitleData = pchTitleBit;
  1303.             pField->offStruct = FIELDOFFSET(MODEMTYPERECORD, ulNum);
  1304.  
  1305.             /* Bezeichnungs-Feld */
  1306.             pField = pField->pNextFieldInfo;
  1307.  
  1308.             pField->cb = sizeof(FIELDINFO);
  1309.             pField->flData = CFA_STRING | CFA_HORZSEPARATOR | CFA_LEFT;
  1310.             pField->flTitle = CFA_FITITLEREADONLY | CFA_LEFT;
  1311.             pField->pTitleData = pchTitleDesc;
  1312.             pField->offStruct = FIELDOFFSET(MODEMTYPERECORD, pchDesc);
  1313.  
  1314.             /* Einfuegen */
  1315.             InfoInsert.cb = sizeof(InfoInsert);
  1316.             InfoInsert.pFieldInfoOrder = (PFIELDINFO) CMA_FIRST;
  1317.             InfoInsert.fInvalidateFieldInfo = TRUE;
  1318.             InfoInsert.cFieldInfoInsert = 2;
  1319.  
  1320.             WinSendDlgItemMsg(hwnd, IDD_MODEMTYPES+3, CM_INSERTDETAILFIELDINFO,
  1321.                               pFirstField,
  1322.                               &InfoInsert);
  1323.          }
  1324.  
  1325.          /* Container */
  1326.          cnrinfo.cb = sizeof(cnrinfo);
  1327.          cnrinfo.flWindowAttr = CV_DETAIL | CA_DETAILSVIEWTITLES;
  1328.          WinSendDlgItemMsg(hwnd, IDD_MODEMTYPES+3, CM_SETCNRINFO, &cnrinfo,
  1329.                            MPFROMLONG(CMA_FLWINDOWATTR));
  1330.  
  1331.          RefreshModemTypeList(hwnd, IDD_MODEMTYPES+3, &nodelist);
  1332.          break;
  1333.  
  1334.       case WM_COMMAND:
  1335.          if (SHORT1FROMMP(mp1) == IDD_MODEMTYPES+8) /* Aendern-Button */
  1336.          {
  1337.             PMODEMTYPERECORD pRecord;
  1338.  
  1339.             pRecord = WinSendDlgItemMsg(hwnd, IDD_MODEMTYPES+3, CM_QUERYRECORDEMPHASIS,
  1340.                                         MPFROMLONG(CMA_FIRST),
  1341.                                         MPFROMSHORT(CRA_CURSORED));
  1342.             if (pRecord)
  1343.             {
  1344.                WinQueryDlgItemText(hwnd, IDD_MODEMTYPES+7, LEN_MODEMTYPE+1,
  1345.                                    pRecord->pchDesc);
  1346.                WinSendDlgItemMsg(hwnd, IDD_MODEMTYPES+3, CM_INVALIDATERECORD,
  1347.                                  &pRecord, MPFROM2SHORT(1, CMA_TEXTCHANGED));
  1348.                dirtyflags.nodedirty = TRUE;
  1349.             }
  1350.  
  1351.          }
  1352.          return (MRESULT) FALSE;
  1353.  
  1354.       case WM_CONTROL:
  1355.          if (SHORT1FROMMP(mp1) == IDD_MODEMTYPES+4 || /* Typ-Radiobuttons */
  1356.              SHORT1FROMMP(mp1) == IDD_MODEMTYPES+5)
  1357.          {
  1358.             if (SHORT2FROMMP(mp1) == BN_CLICKED ||
  1359.                 SHORT2FROMMP(mp1) == BN_DBLCLICKED)
  1360.             {
  1361.                if (WinQueryButtonCheckstate(hwnd, IDD_MODEMTYPES+4))
  1362.                {
  1363.                   nodelist.ulOptions &= ~MODEMFLAGS_BYTETYPE;
  1364.                   RefreshModemTypeList(hwnd, IDD_MODEMTYPES+3, &nodelist);
  1365.                }
  1366.                else
  1367.                {
  1368.                   nodelist.ulOptions |= MODEMFLAGS_BYTETYPE;
  1369.                   RefreshModemTypeList(hwnd, IDD_MODEMTYPES+3, &nodelist);
  1370.                }
  1371.                dirtyflags.nodedirty = TRUE;
  1372.  
  1373.                /* Beschreibung anpassen */
  1374.                pField = WinSendDlgItemMsg(hwnd, IDD_MODEMTYPES+3, CM_QUERYDETAILFIELDINFO,
  1375.                                           NULL, MPFROMSHORT(CMA_FIRST));
  1376.                if (pField)
  1377.                {
  1378.                   if (nodelist.ulOptions & MODEMFLAGS_BYTETYPE)
  1379.                      pField->pTitleData = pchTitleByte;
  1380.                   else
  1381.                      pField->pTitleData = pchTitleBit;
  1382.  
  1383.                   WinSendDlgItemMsg(hwnd, IDD_MODEMTYPES+3, CM_INVALIDATEDETAILFIELDINFO,
  1384.                                     NULL, NULL);
  1385.                }
  1386.             }
  1387.          }
  1388.          if (SHORT1FROMMP(mp1) == IDD_MODEMTYPES+3) /* Container */
  1389.             if (SHORT2FROMMP(mp1) == CN_EMPHASIS)
  1390.             {
  1391.                PNOTIFYRECORDEMPHASIS pNotify = mp2;
  1392.  
  1393.                if (pNotify->fEmphasisMask & CRA_CURSORED)
  1394.                   if (pNotify->pRecord->flRecordAttr & CRA_CURSORED)
  1395.                      WinSetDlgItemText(hwnd, IDD_MODEMTYPES+7, ((PMODEMTYPERECORD)pNotify->pRecord)->pchDesc);
  1396.             }
  1397.          break;
  1398.  
  1399.       case WM_CLOSE:
  1400.       case WM_DESTROY:
  1401.          break;
  1402.  
  1403.       default:
  1404.          break;
  1405.    }
  1406.    return WinDefDlgProc(hwnd, message, mp1, mp2);
  1407. }
  1408.  
  1409. static void RefreshModemTypeList(HWND hwndDlg, ULONG ulIdCnr, NODELISTOPT *pNodelist)
  1410. {
  1411.    HWND hwndCnr = WinWindowFromID(hwndDlg, ulIdCnr);
  1412.    PMODEMTYPERECORD pRecord, pFirstRecord;
  1413.    ULONG ulNum;
  1414.    int i;
  1415.    RECORDINSERT RecordInsert;
  1416.  
  1417.    /* alle Items loeschen */
  1418.    WinSendMsg(hwndCnr, CM_REMOVERECORD, NULL, MPFROM2SHORT(0, CMA_FREE));
  1419.  
  1420.    /* neue Items einfuegen */
  1421.    if (pNodelist->ulOptions & MODEMFLAGS_BYTETYPE)
  1422.       ulNum = MAX_MODEMTYPES_BYTE;
  1423.    else
  1424.       ulNum = MAX_MODEMTYPES;
  1425.  
  1426.    pFirstRecord = WinSendMsg(hwndCnr, CM_ALLOCRECORD,
  1427.                              MPFROMLONG(sizeof(MODEMTYPERECORD) - sizeof(MINIRECORDCORE)),
  1428.                              MPFROMSHORT(ulNum));
  1429.    pRecord = pFirstRecord;
  1430.  
  1431.    for (i=0; i<ulNum; i++)
  1432.    {
  1433.       if (pRecord)
  1434.       {
  1435.          if (pNodelist->ulOptions & MODEMFLAGS_BYTETYPE)
  1436.          {
  1437.             pRecord->ulNum = i+1;
  1438.             pRecord->pchDesc = pNodelist->bytetypes[i];
  1439.          }
  1440.          else
  1441.          {
  1442.             pRecord->ulNum = i;
  1443.             pRecord->pchDesc = pNodelist->modemtype[i];
  1444.          }
  1445.  
  1446.          pRecord = (PMODEMTYPERECORD) pRecord->RecordCore.preccNextRecord;
  1447.       }
  1448.    }
  1449.  
  1450.    /* Einfuegen */
  1451.    RecordInsert.cb = sizeof(RecordInsert);
  1452.    RecordInsert.pRecordOrder = (PRECORDCORE) CMA_FIRST;
  1453.    RecordInsert.pRecordParent = NULL;
  1454.    RecordInsert.fInvalidateRecord = TRUE;
  1455.    RecordInsert.zOrder = CMA_TOP;
  1456.    RecordInsert.cRecordsInsert = ulNum;
  1457.    WinSendMsg(hwndCnr, CM_INSERTRECORD, pFirstRecord, &RecordInsert);
  1458.  
  1459.    return;
  1460. }
  1461.  
  1462. /*------------------------------- MsgOptProc --------------------------------*/
  1463. /* Dialog-Prozedur des Msg-Option-Dialogs                                    */
  1464. /*---------------------------------------------------------------------------*/
  1465.  
  1466. static MRESULT EXPENTRY MsgOptProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  1467. {
  1468.    extern GENERALOPT generaloptions;
  1469.    extern DIRTYFLAGS dirtyflags;
  1470.    extern BOOL isregistered;
  1471.    BOOL booltemp;
  1472.  
  1473.    switch(message)
  1474.    {
  1475.       case WM_COMMAND:
  1476.          return (MRESULT) FALSE;
  1477.  
  1478.       case WM_INITDLG:
  1479.          WinCheckButton(parent, IDD_MSGOPT+6, generaloptions.tearinnet);
  1480.          WinCheckButton(parent, IDD_MSGOPT+1, generaloptions.origininnet);
  1481.          WinCheckButton(parent, IDD_MSGOPT+8, generaloptions.scanatstartup);
  1482.          WinCheckButton(parent, IDD_MSGOPT+10, generaloptions.beeponpersonal);
  1483.          WinCheckButton(parent, IDD_MSGOPT+3, generaloptions.nohighlight);
  1484.          WinCheckButton(parent, IDD_MSGOPT+4, generaloptions.genFwdSubj);
  1485.          WinCheckButton(parent, IDD_MSGOPT+5, generaloptions.usepid);
  1486.          SetFocusControl(parent, IDD_MSGOPT+5);
  1487.          return (MRESULT) TRUE;
  1488.  
  1489.       case WM_CLOSE:
  1490.       case WM_DESTROY:
  1491.          booltemp=WinQueryButtonCheckstate(parent, IDD_MSGOPT+6);
  1492.          if (booltemp != generaloptions.tearinnet)
  1493.          {
  1494.             generaloptions.tearinnet=booltemp;
  1495.             dirtyflags.optionsdirty=TRUE;
  1496.          }
  1497.          booltemp=WinQueryButtonCheckstate(parent, IDD_MSGOPT+8);
  1498.          if (booltemp != generaloptions.scanatstartup)
  1499.          {
  1500.             generaloptions.scanatstartup=booltemp;
  1501.             dirtyflags.optionsdirty=TRUE;
  1502.          }
  1503.          booltemp=WinQueryButtonCheckstate(parent, IDD_MSGOPT+10);
  1504.          if (booltemp != generaloptions.beeponpersonal)
  1505.          {
  1506.             generaloptions.beeponpersonal=booltemp;
  1507.             dirtyflags.optionsdirty=TRUE;
  1508.          }
  1509.          booltemp=WinQueryButtonCheckstate(parent, IDD_MSGOPT+1);
  1510.          if (booltemp != generaloptions.origininnet)
  1511.          {
  1512.             generaloptions.origininnet=booltemp;
  1513.             dirtyflags.optionsdirty=TRUE;
  1514.          }
  1515.          booltemp=WinQueryButtonCheckstate(parent, IDD_MSGOPT+5);
  1516.          if (booltemp != generaloptions.usepid)
  1517.          {
  1518.             generaloptions.usepid=booltemp;
  1519.             dirtyflags.optionsdirty=TRUE;
  1520.          }
  1521.          booltemp=WinQueryButtonCheckstate(parent, IDD_MSGOPT+3);
  1522.          if (booltemp != generaloptions.nohighlight)
  1523.          {
  1524.             generaloptions.nohighlight=booltemp;
  1525.             dirtyflags.optionsdirty=TRUE;
  1526.          }
  1527.          booltemp=WinQueryButtonCheckstate(parent, IDD_MSGOPT+4);
  1528.          if (booltemp != generaloptions.genFwdSubj)
  1529.          {
  1530.             generaloptions.genFwdSubj=booltemp;
  1531.             dirtyflags.optionsdirty=TRUE;
  1532.          }
  1533.          break;
  1534.  
  1535.       default:
  1536.          break;
  1537.    }
  1538.    return WinDefDlgProc(parent,message,mp1,mp2);
  1539. }
  1540.  
  1541. /*------------------------------- StartupProc -------------------------------*/
  1542. /* Dialog-Prozedur des Startup-Dialogs                                       */
  1543. /*---------------------------------------------------------------------------*/
  1544.  
  1545. static MRESULT EXPENTRY StartupProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  1546. {
  1547.    extern GENERALOPT generaloptions;
  1548.    extern DIRTYFLAGS dirtyflags;
  1549.    BOOL booltemp;
  1550.    char pchTemp[LEN_AREATAG+1];
  1551.  
  1552.    switch(message)
  1553.    {
  1554.       case WM_INITDLG:
  1555.          WinCheckButton(parent, IDD_STARTUP+3, generaloptions.uselastarea);
  1556.          WinCheckButton(parent, IDD_STARTUP+4, !generaloptions.uselastarea);
  1557.          WinEnableControl(parent, IDD_STARTUP+5, !generaloptions.uselastarea);
  1558.          WinSendDlgItemMsg(parent, IDD_STARTUP+5, EM_SETTEXTLIMIT,
  1559.                            MPFROMLONG(LEN_AREATAG), NULL);
  1560.          WinSetDlgItemText(parent, IDD_STARTUP+5, generaloptions.startarea);
  1561.          SetFocusControl(parent, IDD_STARTUP+3);
  1562.          return (MRESULT) TRUE;
  1563.  
  1564.       case WM_COMMAND:
  1565.          return (MRESULT) FALSE;
  1566.  
  1567.       case WM_CONTROL:
  1568.          if ((SHORT1FROMMP(mp1)==IDD_STARTUP+3 ||
  1569.               SHORT1FROMMP(mp1)==IDD_STARTUP+4) &&
  1570.              (SHORT2FROMMP(mp1)==BN_CLICKED ||
  1571.               SHORT2FROMMP(mp1)==BN_DBLCLICKED))
  1572.          {
  1573.             booltemp=WinQueryButtonCheckstate(parent, IDD_STARTUP+4);
  1574.             WinEnableControl(parent, IDD_STARTUP+5, booltemp);
  1575.          }
  1576.          break;
  1577.  
  1578.       case WM_CLOSE:
  1579.       case WM_DESTROY:
  1580.          booltemp=WinQueryButtonCheckstate(parent, IDD_STARTUP+3);
  1581.          if (booltemp != generaloptions.uselastarea)
  1582.          {
  1583.             generaloptions.uselastarea=booltemp;
  1584.             dirtyflags.optionsdirty=TRUE;
  1585.          }
  1586.          WinQueryDlgItemText(parent, IDD_STARTUP+5, LEN_AREATAG+1, pchTemp);
  1587.          if (strcmp(generaloptions.startarea, pchTemp))
  1588.          {
  1589.             strcpy(generaloptions.startarea, pchTemp);
  1590.             dirtyflags.optionsdirty=TRUE;
  1591.          }
  1592.          break;
  1593.  
  1594.       default:
  1595.          break;
  1596.    }
  1597.    return WinDefDlgProc(parent,message,mp1,mp2);
  1598. }
  1599.  
  1600. /*------------------------------- EditorOptProc -----------------------------*/
  1601. /* Dialog-Prozedur des Editor-Optionen-Dialogs                               */
  1602. /*---------------------------------------------------------------------------*/
  1603.  
  1604. static MRESULT EXPENTRY EditorOptProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  1605. {
  1606.    extern GENERALOPT generaloptions;
  1607.    extern DIRTYFLAGS dirtyflags;
  1608.    extern WINDOWCOLORS windowcolors;
  1609.    LONG lTemp;
  1610.  
  1611.    switch(message)
  1612.    {
  1613.       case WM_INITDLG:
  1614.          /* Tabulator-Settings */
  1615.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+4, SPBM_SETLIMITS,
  1616.                            MPFROMLONG(20), MPFROMLONG(1));
  1617.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+4, SPBM_SETCURRENTVALUE,
  1618.                            MPFROMLONG(generaloptions.lTabSize), NULL);
  1619.          /* Message-laenge */
  1620.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+14, SPBM_SETLIMITS,
  1621.                            MPFROMLONG(500), MPFROMLONG(2));
  1622.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+14, SPBM_SETCURRENTVALUE,
  1623.                            MPFROMLONG(generaloptions.lMaxMsgLen), NULL);
  1624.  
  1625.          /* Farben im Value-Set initialisieren */
  1626.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+12, VM_SETITEM,
  1627.                            MPFROM2SHORT(1, 1),
  1628.                            MPFROMLONG(windowcolors.viewerback));
  1629.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+12, VM_SETITEM,
  1630.                            MPFROM2SHORT(2, 1),
  1631.                            MPFROMLONG(windowcolors.viewerfore));
  1632.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+12, VM_SETITEM,
  1633.                            MPFROM2SHORT(3, 1),
  1634.                            MPFROMLONG(windowcolors.viewerquote));
  1635.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+12, VM_SETITEM,
  1636.                            MPFROM2SHORT(4, 1),
  1637.                            MPFROMLONG(windowcolors.viewertearline));
  1638.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+12, VM_SETITEM,
  1639.                            MPFROM2SHORT(5, 1),
  1640.                            MPFROMLONG(windowcolors.viewerorigin));
  1641.  
  1642.          /* Erstes Element im VS auswaehlen */
  1643.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+12, VM_SELECTITEM,
  1644.                            MPFROM2SHORT(1, 1), NULL);
  1645.  
  1646.          /* Fadenkreuz im Color-Wheel entsprechend setzen */
  1647.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+13, CLSM_SETRGB,
  1648.                            &windowcolors.viewerback,
  1649.                            NULL);
  1650.          break;
  1651.  
  1652.       case WM_CONTROL:
  1653.          switch(SHORT1FROMMP(mp1))
  1654.          {
  1655.             case IDD_EDITOROPT+4:
  1656.                if (!WinSendDlgItemMsg(parent, IDD_EDITOROPT+4, SPBM_QUERYVALUE,
  1657.                                       NULL,
  1658.                                       MPFROM2SHORT(0, SPBQ_ALWAYSUPDATE)))
  1659.                   WinAlarm(HWND_DESKTOP, WA_ERROR);
  1660.                break;
  1661.  
  1662.             case IDD_EDITOROPT+14:
  1663.                if (!WinSendDlgItemMsg(parent, IDD_EDITOROPT+14, SPBM_QUERYVALUE,
  1664.                                       NULL,
  1665.                                       MPFROM2SHORT(0, SPBQ_ALWAYSUPDATE)))
  1666.                   WinAlarm(HWND_DESKTOP, WA_ERROR);
  1667.                break;
  1668.  
  1669.             case IDD_EDITOROPT+12:  /* Value-Set */
  1670.                if (SHORT2FROMMP(mp1) == VN_SELECT)
  1671.                {
  1672.                   ULONG ulColor;
  1673.  
  1674.                   /* neue Selektion abfragen */
  1675.                   ulColor=(ULONG)WinSendDlgItemMsg(parent, IDD_EDITOROPT+12,
  1676.                                                    VM_QUERYITEM, mp2, NULL);
  1677.  
  1678.                   /* Fadenkreuz setzen */
  1679.                   WinSendDlgItemMsg(parent, IDD_EDITOROPT+13,
  1680.                                     CLSM_SETRGB, &ulColor, NULL);
  1681.                }
  1682.                break;
  1683.  
  1684.             case IDD_EDITOROPT+13:  /* Color-Wheel */
  1685.                if (SHORT2FROMMP(mp1) == CLSN_RGB)
  1686.                {
  1687.                   MRESULT selected;
  1688.                   ULONG ulVer[2]={0,0};
  1689.  
  1690.                   DosQuerySysInfo(QSV_VERSION_MAJOR, QSV_VERSION_MINOR, ulVer, sizeof(ulVer));
  1691.  
  1692.                   /* selektiertes Item im Value-Set abfragen */
  1693.                   selected=WinSendDlgItemMsg(parent, IDD_EDITOROPT+12, VM_QUERYSELECTEDITEM,
  1694.                                              NULL, NULL);
  1695.  
  1696.                   /* Farbe updaten */
  1697.                   WinSendDlgItemMsg(parent, IDD_EDITOROPT+12, VM_SETITEM,
  1698.                                     selected, mp2);
  1699.  
  1700.                   /* Farbe in Settings eintragen */
  1701.                   switch(SHORT1FROMMR(selected))
  1702.                   {
  1703.                      case 1:
  1704.                         windowcolors.viewerback= (LONG) mp2;
  1705.                         if (ulVer[0] > 20 || ulVer[1]>=11)
  1706.                         {
  1707.                            /* OS/2 2.11 verwendet RGB-Farben f. MLE */
  1708.                            windowcolors.editback=(LONG) mp2;
  1709.                         }
  1710.                         break;
  1711.  
  1712.                      case 2:
  1713.                         windowcolors.viewerfore= (LONG) mp2;
  1714.                         if (ulVer[0] > 20 || ulVer[1]>=11)
  1715.                         {
  1716.                            /* OS/2 2.11 verwendet RGB-Farben f. MLE */
  1717.                            windowcolors.editfore=(LONG) mp2;
  1718.                         }
  1719.                         break;
  1720.  
  1721.                      case 3:
  1722.                         windowcolors.viewerquote= (LONG) mp2;
  1723.                         break;
  1724.  
  1725.                      case 4:
  1726.                         windowcolors.viewertearline= (LONG) mp2;
  1727.                         break;
  1728.  
  1729.                      case 5:
  1730.                         windowcolors.viewerorigin= (LONG) mp2;
  1731.                         break;
  1732.  
  1733.                      default:
  1734.                         break;
  1735.                   }
  1736.                }
  1737.                break;
  1738.  
  1739.             default:
  1740.                break;
  1741.          }
  1742.          break;
  1743.  
  1744.  
  1745.       case WM_DESTROY:
  1746.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+4, SPBM_QUERYVALUE,
  1747.                            &lTemp,
  1748.                            MPFROM2SHORT(0, SPBQ_ALWAYSUPDATE));
  1749.          if (generaloptions.lTabSize != lTemp)
  1750.          {
  1751.             generaloptions.lTabSize = lTemp;
  1752.             dirtyflags. optionsdirty=TRUE;
  1753.          }
  1754.          WinSendDlgItemMsg(parent, IDD_EDITOROPT+14, SPBM_QUERYVALUE,
  1755.                            &lTemp,
  1756.                            MPFROM2SHORT(0, SPBQ_ALWAYSUPDATE));
  1757.          if (generaloptions.lMaxMsgLen != lTemp)
  1758.          {
  1759.             generaloptions.lMaxMsgLen = lTemp;
  1760.             dirtyflags. optionsdirty=TRUE;
  1761.          }
  1762.          break;
  1763.  
  1764.       case WM_COMMAND:
  1765.          return (MRESULT) FALSE;
  1766.  
  1767.       default:
  1768.          break;
  1769.    }
  1770.    return WinDefDlgProc(parent,message,mp1,mp2);
  1771. }
  1772.  
  1773. /*----------------------------- SquishOptProc -------------------------------*/
  1774. /* Dialog-Prozedur des Squish-Optionen-Dialogs                               */
  1775. /*---------------------------------------------------------------------------*/
  1776.  
  1777. static MRESULT EXPENTRY SquishOptProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  1778. {
  1779.    BOOL booltemp;
  1780.    char pathnamebuffer[LEN_PATHNAME+1];
  1781.    extern USERDATAOPT userdaten;
  1782.    extern PATHNAMES pathnames;
  1783.    extern MISCOPTIONS miscoptions;
  1784.    extern GENERALOPT generaloptions;
  1785.    extern DIRTYFLAGS dirtyflags;
  1786.    extern HAB anchor;
  1787.    extern HWND hwndhelp;
  1788.    static HWND hwndSetupFrame;
  1789.    ULONG ulTemp;
  1790.  
  1791.    switch(message)
  1792.    {
  1793.       case WM_COMMAND:
  1794.          if (SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON)
  1795.          {
  1796.             switch (SHORT1FROMMP(mp1))
  1797.             {
  1798.                case IDD_SQUISHOPTIONS+5:
  1799.                   WinQueryDlgItemText(parent, IDD_SQUISHOPTIONS+3,
  1800.                                       LEN_PATHNAME+1, pathnamebuffer);
  1801.                   if (GetPathname(parent, pathnamebuffer)==DID_OK)
  1802.                   {
  1803.                      if (!ReadNewCfgFile(parent, hwndSetupFrame, pathnamebuffer))
  1804.                         WinSetDlgItemText(parent, IDD_SQUISHOPTIONS+3,
  1805.                                           pathnamebuffer);
  1806.                   }
  1807.                   break;
  1808.  
  1809.                default:
  1810.                   break;
  1811.             }
  1812.          }
  1813.          return (MRESULT) FALSE;
  1814.  
  1815.       case WM_INITDLG:
  1816.          hwndSetupFrame=WinQueryWindow(parent, QW_PARENT);
  1817.          WinSubclassWindow(WinWindowFromID(parent, IDD_SQUISHOPTIONS+3),
  1818.                            FileEntryProc);
  1819.          WinSendDlgItemMsg(parent,IDD_SQUISHOPTIONS+3, EM_SETTEXTLIMIT,
  1820.                            MPFROMSHORT(LEN_PATHNAME), NULL);
  1821.          WinSendDlgItemMsg(parent,IDD_SQUISHOPTIONS+3, EM_SETREADONLY,
  1822.                            MPFROMSHORT(TRUE), NULL);
  1823.  
  1824.          /* Tosser-Pfad */
  1825.          WinSetDlgItemText(parent, IDD_SQUISHOPTIONS+3,
  1826.                            pathnames.squishcfg);
  1827.          WinCheckButton(parent, IDD_SQUISHOPTIONS+2, miscoptions.readcfg);
  1828.          WinEnableControl(parent, IDD_SQUISHOPTIONS+3, miscoptions.readcfg);
  1829.          WinEnableControl(parent, IDD_SQUISHOPTIONS+5, miscoptions.readcfg);
  1830.          WinEnableControl(parent, IDD_SQUISHOPTIONS+7, miscoptions.readcfg);
  1831.  
  1832.          SetCfgType(parent, miscoptions.ulCfgType);
  1833.  
  1834.          break;
  1835.  
  1836.       case WM_CONTROL:
  1837.          if (SHORT1FROMMP(mp1)==IDD_SQUISHOPTIONS+2 &&
  1838.              (SHORT2FROMMP(mp1)==BN_CLICKED || SHORT2FROMMP(mp1)==BN_DBLCLICKED))
  1839.          {
  1840.             booltemp=WinQueryButtonCheckstate(parent, IDD_SQUISHOPTIONS+2);
  1841.             if (!userdaten.username[0][0])
  1842.                booltemp=FALSE;
  1843.             WinEnableControl(parent, IDD_SQUISHOPTIONS+3, booltemp);
  1844.             WinEnableControl(parent, IDD_SQUISHOPTIONS+5, booltemp);
  1845.             WinEnableControl(parent, IDD_SQUISHOPTIONS+7, booltemp);
  1846.             miscoptions.readcfg=booltemp;
  1847.          }
  1848.          if (SHORT1FROMMP(mp1)==IDD_SQUISHOPTIONS+3 &&
  1849.              SHORT2FROMMP(mp1)==EN_FILEDROPPED)
  1850.          {
  1851.             WinQueryDlgItemText(parent, IDD_SQUISHOPTIONS+3,
  1852.                                 LEN_PATHNAME+1, pathnamebuffer);
  1853.  
  1854.             ReadNewCfgFile(parent, hwndSetupFrame, pathnamebuffer);
  1855.          }
  1856.          break;
  1857.  
  1858.       case WM_DESTROY:
  1859.       case WM_CLOSE:
  1860.          WinQueryDlgItemText(parent, IDD_SQUISHOPTIONS+3, LEN_PATHNAME+1,
  1861.                              pathnamebuffer);
  1862.          if (strcmp(pathnames.squishcfg, pathnamebuffer))
  1863.             strcpy(pathnames.squishcfg, pathnamebuffer);
  1864.  
  1865.          ulTemp = GetCfgType(parent);
  1866.          if (miscoptions.ulCfgType != ulTemp)
  1867.          {
  1868.             miscoptions.ulCfgType = ulTemp;
  1869.          }
  1870.          break;
  1871.  
  1872.       case SUM_CHECKSETUP:
  1873.          if (!userdaten.username[0][0])
  1874.          {
  1875.             WinEnableControl(parent, IDD_SQUISHOPTIONS+3, FALSE);
  1876.             WinEnableControl(parent, IDD_SQUISHOPTIONS+5, FALSE);
  1877.             WinEnableControl(parent, IDD_SQUISHOPTIONS+7, FALSE);
  1878.             WinEnableControl(parent, IDD_SQUISHOPTIONS+2, FALSE);
  1879.          }
  1880.          else
  1881.          {
  1882.             if (miscoptions.readcfg)
  1883.             {
  1884.                WinEnableControl(parent, IDD_SQUISHOPTIONS+3, TRUE);
  1885.                WinEnableControl(parent, IDD_SQUISHOPTIONS+5, TRUE);
  1886.                WinEnableControl(parent, IDD_SQUISHOPTIONS+7, TRUE);
  1887.             }
  1888.             else
  1889.             {
  1890.                WinEnableControl(parent, IDD_SQUISHOPTIONS+3, FALSE);
  1891.                WinEnableControl(parent, IDD_SQUISHOPTIONS+5, FALSE);
  1892.                WinEnableControl(parent, IDD_SQUISHOPTIONS+7, FALSE);
  1893.             }
  1894.             WinEnableControl(parent, IDD_SQUISHOPTIONS+2, TRUE);
  1895.          }
  1896.          break;
  1897.  
  1898.       default:
  1899.          break;
  1900.    }
  1901.    return WinDefDlgProc(parent,message,mp1,mp2);
  1902. }
  1903.  
  1904. static int ReadNewCfgFile(HWND parent, HWND hwndSetupFrame, char *pchPathName)
  1905. {
  1906.    extern PATHNAMES pathnames;
  1907.    extern AREALIST arealiste;
  1908.  
  1909.    ULONG ulCfgType = GetCfgType(parent);
  1910.    ULONG rc;
  1911.  
  1912.    rc = ReReadAreas(anchor, pchPathName, ulCfgType);
  1913.  
  1914.    if (rc)
  1915.    {
  1916.       HandleInitErrors(parent, rc);
  1917.  
  1918.       return 1;
  1919.    }
  1920.    else
  1921.    {
  1922.       WinSetDlgItemText(parent, IDD_SQUISHOPTIONS+3, pchPathName);
  1923.  
  1924.       /* Squish-Pfad kopieren */
  1925.       strcpy(pathnames.squishcfg, pchPathName);
  1926.       arealiste.bDirty = TRUE;
  1927.    }
  1928.    SendMsg(hwndSetupFrame, SUM_REFRESHUSER, NULL, NULL);
  1929.  
  1930.    return 0;
  1931. }
  1932.  
  1933. static ULONG GetCfgType(HWND hwndDlg)
  1934. {
  1935.    SHORT sItem;
  1936.  
  1937.    sItem = (SHORT) WinSendDlgItemMsg(hwndDlg, IDD_SQUISHOPTIONS+7,
  1938.                                      LM_QUERYSELECTION,
  1939.                                      MPFROMSHORT(LIT_FIRST), NULL);
  1940.    if (sItem != LIT_NONE)
  1941.    {
  1942.       return (ULONG) WinSendDlgItemMsg(hwndDlg, IDD_SQUISHOPTIONS+7, LM_QUERYITEMHANDLE,
  1943.                                        MPFROMSHORT(sItem), NULL);
  1944.    }
  1945.    else
  1946.       return 0;
  1947. }
  1948.  
  1949. static void SetCfgType(HWND hwndDlg, ULONG ulCfgType)
  1950. {
  1951.    extern PCFGDLL pCfgDLLs;
  1952.    PCFGDLL pTemp=NULL;
  1953.    SHORT sItem;
  1954.    HWND hwndList = WinWindowFromID(hwndDlg, IDD_SQUISHOPTIONS+7);
  1955.  
  1956.    while (pTemp = CFG_FindFormat(pCfgDLLs, CFGTYPE_ANY, pTemp))
  1957.    {
  1958.       sItem = (SHORT) SendMsg(hwndList, LM_INSERTITEM, MPFROMSHORT(LIT_SORTASCENDING),
  1959.                               pTemp->pchFormatName);
  1960.       if (sItem >= 0)
  1961.          SendMsg(hwndList, LM_SETITEMHANDLE, MPFROMSHORT(sItem),
  1962.                  MPFROMLONG(pTemp->ulFormatID));
  1963.       if (ulCfgType == pTemp->ulFormatID)
  1964.          SendMsg(hwndList, LM_SELECTITEM, MPFROMSHORT(sItem), MPFROMSHORT(TRUE));
  1965.    }
  1966.  
  1967.    return;
  1968. }
  1969.  
  1970. static MRESULT EXPENTRY TosserPathsProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  1971. {
  1972.    BOOL booltemp;
  1973.    char pathnamebuffer[LEN_PATHNAME+1];
  1974.    extern PATHNAMES pathnames;
  1975.    extern MISCOPTIONS miscoptions;
  1976.    extern ECHOTOSSOPT echotossoptions;
  1977.    extern DIRTYFLAGS dirtyflags;
  1978.    extern HAB anchor;
  1979.    extern GENERALOPT generaloptions;
  1980.    LONG spinbuffer;
  1981.    extern HWND hwndhelp;
  1982.  
  1983.    switch(message)
  1984.    {
  1985.       case WM_COMMAND:
  1986.          return (MRESULT) FALSE;
  1987.  
  1988.       case WM_INITDLG:
  1989.          /* ECHOMAIL.JAM */
  1990.          WinSendDlgItemMsg(parent, IDD_TOSSERPATHS+6, EM_SETTEXTLIMIT,
  1991.                            MPFROMSHORT(LEN_PATHNAME), NULL);
  1992.          WinSetDlgItemText(parent, IDD_TOSSERPATHS+6, generaloptions.jampath);
  1993.  
  1994.          /* Attach */
  1995.          WinSendDlgItemMsg(parent, IDD_TOSSERPATHS+12, EM_SETTEXTLIMIT,
  1996.                            MPFROMSHORT(LEN_PATHNAME), NULL);
  1997.          WinSetDlgItemText(parent, IDD_TOSSERPATHS+12, generaloptions.attachpath);
  1998.  
  1999.          /* Offset-Spinbutton */
  2000.          WinSendDlgItemMsg(parent,IDD_TOSSERPATHS+9, SPBM_SETLIMITS,
  2001.                            MPFROMLONG(500), MPFROMLONG(0));
  2002.          WinSendDlgItemMsg(parent, IDD_TOSSERPATHS+9, SPBM_SETCURRENTVALUE,
  2003.                            MPFROMLONG(miscoptions.lastreadoffset), NULL);
  2004.  
  2005.          /* Echotoss-Optionen */
  2006.          WinCheckButton(parent, IDD_TOSSERPATHS+3, echotossoptions.useechotoss);
  2007.          WinEnableControl(parent, IDD_TOSSERPATHS+4, echotossoptions.useechotoss);
  2008.          WinSendDlgItemMsg(parent,IDD_TOSSERPATHS+4, EM_SETTEXTLIMIT,
  2009.                            MPFROMSHORT(LEN_PATHNAME), NULL);
  2010.          WinSetDlgItemText(parent, IDD_TOSSERPATHS+4, echotossoptions.pchEchoToss);
  2011.          break;
  2012.  
  2013.       case WM_CONTROL:
  2014.          if (SHORT1FROMMP(mp1)==IDD_TOSSERPATHS+3 &&
  2015.              (SHORT2FROMMP(mp1)==BN_CLICKED || SHORT2FROMMP(mp1)==BN_DBLCLICKED))
  2016.          {
  2017.             booltemp=WinQueryButtonCheckstate(parent, IDD_TOSSERPATHS+3);
  2018.             WinEnableControl(parent, IDD_TOSSERPATHS+4, booltemp);
  2019.          }
  2020.          if (SHORT1FROMMP(mp1)==IDD_SQUISHOPTIONS+9)
  2021.          {
  2022.             if (!WinSendDlgItemMsg(parent, IDD_SQUISHOPTIONS+9, SPBM_QUERYVALUE,
  2023.                           MPFROMP(&spinbuffer),
  2024.                           MPFROM2SHORT((USHORT)0, SPBQ_ALWAYSUPDATE)))
  2025.                WinAlarm(HWND_DESKTOP, WA_ERROR);
  2026.          }
  2027.          break;
  2028.  
  2029.       case WM_DESTROY:
  2030.       case WM_CLOSE:
  2031.          if (!WinSendDlgItemMsg(parent, IDD_TOSSERPATHS+9, SPBM_QUERYVALUE,
  2032.                        MPFROMP(&miscoptions.lastreadoffset),
  2033.                        MPFROM2SHORT((USHORT)0, SPBQ_ALWAYSUPDATE)))
  2034.             DosBeep(1000,100);
  2035.  
  2036.          WinQueryDlgItemText(parent, IDD_TOSSERPATHS+6, LEN_PATHNAME+1,
  2037.                              pathnamebuffer);
  2038.          RemoveBackslash(pathnamebuffer);
  2039.          if (strcmp(generaloptions.jampath, pathnamebuffer))
  2040.          {
  2041.             strcpy(generaloptions.jampath, pathnamebuffer);
  2042.             dirtyflags.optionsdirty = TRUE;
  2043.          }
  2044.  
  2045.          WinQueryDlgItemText(parent, IDD_TOSSERPATHS+12, LEN_PATHNAME+1,
  2046.                              pathnamebuffer);
  2047.          RemoveBackslash(pathnamebuffer);
  2048.          if (strcmp(generaloptions.attachpath, pathnamebuffer))
  2049.          {
  2050.             strcpy(generaloptions.attachpath, pathnamebuffer);
  2051.             dirtyflags.optionsdirty = TRUE;
  2052.          }
  2053.  
  2054.          booltemp=WinQueryButtonCheckstate(parent, IDD_TOSSERPATHS+3);
  2055.          if (echotossoptions.useechotoss != booltemp)
  2056.          {
  2057.             echotossoptions.useechotoss=booltemp;
  2058.             dirtyflags.echotossdirty=TRUE;
  2059.          }
  2060.          WinQueryDlgItemText(parent, IDD_TOSSERPATHS+4, LEN_PATHNAME+1,
  2061.                              pathnamebuffer);
  2062.          if (strcmp(echotossoptions.pchEchoToss, pathnamebuffer))
  2063.          {
  2064.             strcpy(echotossoptions.pchEchoToss, pathnamebuffer);
  2065.             dirtyflags.echotossdirty=TRUE;
  2066.          }
  2067.          break;
  2068.  
  2069.       default:
  2070.          break;
  2071.    }
  2072.    return WinDefDlgProc(parent, message, mp1, mp2);
  2073. }
  2074.  
  2075. /*----------------------------- RemapSetupProc   ----------------------------*/
  2076. /* Dialog-Prozedur des Drive-Remap-Setups                                    */
  2077. /*---------------------------------------------------------------------------*/
  2078.  
  2079. static MRESULT EXPENTRY RemapSetupProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  2080. {
  2081.    extern DIRTYFLAGS dirtyflags;
  2082.    extern DRIVEREMAP driveremap;
  2083.    static char *pchDrives[] = { "C:", "D:", "E:", "F:", "G:", "H:", "I:", "J:",
  2084.                                 "K:", "L:", "M:", "N:", "O:", "P:", "Q:", "R:",
  2085.                                 "S:", "T:", "U:", "V:", "W:", "X:", "Y:", "Z:"};
  2086.    char chLocal;
  2087.  
  2088.    switch(message)
  2089.    {
  2090.       case WM_INITDLG:
  2091.          /* Remote Drive fuellen */
  2092.          WinSendDlgItemMsg(parent, IDD_DRIVEREMAP+5, SPBM_SETARRAY,
  2093.                            pchDrives, MPFROMSHORT(24));
  2094.  
  2095.          /* Local Drive fuellen */
  2096.          WinSendDlgItemMsg(parent, IDD_DRIVEREMAP+6, SPBM_SETARRAY,
  2097.                            pchDrives, MPFROMSHORT(24));
  2098.  
  2099.          /* Anfangswert setzen */
  2100.          chLocal = driveremap.pchRemapString[0] - 'C';
  2101.          WinSendDlgItemMsg(parent, IDD_DRIVEREMAP+6, SPBM_SETCURRENTVALUE,
  2102.                            MPFROMLONG(chLocal), NULL);
  2103.          break;
  2104.  
  2105.       case WM_CONTROL:
  2106.          if (SHORT1FROMMP(mp1) == IDD_DRIVEREMAP+5) /* Remote Drive */
  2107.          {
  2108.             if (SHORT2FROMMP(mp1) == SPBN_UPARROW ||
  2109.                 SHORT2FROMMP(mp1) == SPBN_DOWNARROW)
  2110.             {
  2111.                char pchTemp[3];
  2112.  
  2113.                WinSendDlgItemMsg(parent, IDD_DRIVEREMAP+5, SPBM_QUERYVALUE,
  2114.                                  pchTemp, MPFROM2SHORT(sizeof(pchTemp),
  2115.                                                        SPBQ_ALWAYSUPDATE));
  2116.                chLocal = driveremap.pchRemapString[pchTemp[0] - 'C'] - 'C';
  2117.  
  2118.                WinSendDlgItemMsg(parent, IDD_DRIVEREMAP+6, SPBM_SETCURRENTVALUE,
  2119.                                  MPFROMLONG(chLocal), NULL);
  2120.             }
  2121.          }
  2122.          if (SHORT1FROMMP(mp1) == IDD_DRIVEREMAP+6) /* Local Drive */
  2123.          {
  2124.             if (SHORT2FROMMP(mp1) == SPBN_UPARROW ||
  2125.                 SHORT2FROMMP(mp1) == SPBN_DOWNARROW)
  2126.             {
  2127.                char pchTemp[3];
  2128.                char pchTemp2[3];
  2129.                WinSendDlgItemMsg(parent, IDD_DRIVEREMAP+5, SPBM_QUERYVALUE,
  2130.                                  pchTemp, MPFROM2SHORT(sizeof(pchTemp),
  2131.                                                        SPBQ_ALWAYSUPDATE));
  2132.                WinSendDlgItemMsg(parent, IDD_DRIVEREMAP+6, SPBM_QUERYVALUE,
  2133.                                  pchTemp2, MPFROM2SHORT(sizeof(pchTemp2),
  2134.                                                        SPBQ_ALWAYSUPDATE));
  2135.                driveremap.pchRemapString[pchTemp[0] - 'C'] = pchTemp2[0];
  2136.                dirtyflags.remapdirty = TRUE;
  2137.             }
  2138.          }
  2139.          break;
  2140.  
  2141.       case WM_COMMAND:
  2142.          return (MRESULT) FALSE;
  2143.  
  2144.       case WM_DESTROY:
  2145.          break;
  2146.  
  2147.       default:
  2148.          break;
  2149.    }
  2150.    return WinDefDlgProc(parent,message,mp1,mp2);
  2151. }
  2152.  
  2153. /*----------------------------- SafetyOptProc    ----------------------------*/
  2154. /* Dialog-Prozedur des Safety-Setups                                         */
  2155. /*---------------------------------------------------------------------------*/
  2156.  
  2157. static MRESULT EXPENTRY SafetyOptProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  2158. {
  2159.    extern DIRTYFLAGS dirtyflags;
  2160.    extern GENERALOPT generaloptions;
  2161.    ULONG ulTemp;
  2162.  
  2163.    switch(msg)
  2164.    {
  2165.       case WM_INITDLG:
  2166.          if (generaloptions.safety & SAFETY_DELMSG)
  2167.             WinCheckButton(hwnd, IDD_SAFETY+2, TRUE);
  2168.          if (generaloptions.safety & SAFETY_SHREDMSG)
  2169.             WinCheckButton(hwnd, IDD_SAFETY+3, TRUE);
  2170.          if (generaloptions.safety & SAFETY_CATCHUP)
  2171.             WinCheckButton(hwnd, IDD_SAFETY+4, TRUE);
  2172.          if (generaloptions.safety & SAFETY_EDITSENT)
  2173.             WinCheckButton(hwnd, IDD_SAFETY+5, TRUE);
  2174.          if (generaloptions.safety & SAFETY_CHANGESETUP)
  2175.             WinCheckButton(hwnd, IDD_SAFETY+6, TRUE);
  2176.          if (generaloptions.safety & SAFETY_DISCARD)
  2177.             WinCheckButton(hwnd, IDD_SAFETY+7, TRUE);
  2178.          break;
  2179.  
  2180.       case WM_COMMAND:
  2181.          return (MRESULT) FALSE;
  2182.  
  2183.       case WM_DESTROY:
  2184.          ulTemp=0;
  2185.          if (WinQueryButtonCheckstate(hwnd, IDD_SAFETY+2))
  2186.             ulTemp |= SAFETY_DELMSG;
  2187.          if (WinQueryButtonCheckstate(hwnd, IDD_SAFETY+3))
  2188.             ulTemp |= SAFETY_SHREDMSG;
  2189.          if (WinQueryButtonCheckstate(hwnd, IDD_SAFETY+4))
  2190.             ulTemp |= SAFETY_CATCHUP;
  2191.          if (WinQueryButtonCheckstate(hwnd, IDD_SAFETY+5))
  2192.             ulTemp |= SAFETY_EDITSENT;
  2193.          if (WinQueryButtonCheckstate(hwnd, IDD_SAFETY+6))
  2194.             ulTemp |= SAFETY_CHANGESETUP;
  2195.          if (WinQueryButtonCheckstate(hwnd, IDD_SAFETY+7))
  2196.             ulTemp |= SAFETY_DISCARD;
  2197.          if (generaloptions.safety != ulTemp)
  2198.          {
  2199.             generaloptions.safety = ulTemp;
  2200.             dirtyflags.optionsdirty = TRUE;
  2201.          }
  2202.          break;
  2203.  
  2204.       default:
  2205.          break;
  2206.    }
  2207.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  2208. }
  2209.  
  2210. /*----------------------------- OpenWinProc ---------------------------------*/
  2211. /* Dialog-Prozedur des Fenster-Setups                                        */
  2212. /*---------------------------------------------------------------------------*/
  2213.  
  2214. static MRESULT EXPENTRY OpenWinProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  2215. {
  2216.    extern OPENWIN OpenWindows;
  2217.  
  2218.    switch(msg)
  2219.    {
  2220.       case WM_INITDLG:
  2221.          CheckOpenWinButton(hwnd, IDD_SU_OPENWIN+3, &OpenWindows, OPENWIN_AREA);
  2222.          CheckOpenWinButton(hwnd, IDD_SU_OPENWIN+4, &OpenWindows, OPENWIN_KLUDGES);
  2223.          CheckOpenWinButton(hwnd, IDD_SU_OPENWIN+5, &OpenWindows, OPENWIN_BOOKMARKS);
  2224.          CheckOpenWinButton(hwnd, IDD_SU_OPENWIN+6, &OpenWindows, OPENWIN_THRL);
  2225.          CheckOpenWinButton(hwnd, IDD_SU_OPENWIN+7, &OpenWindows, OPENWIN_MSGL);
  2226.          break;
  2227.  
  2228.       case WM_COMMAND:
  2229.          return (MRESULT) FALSE;
  2230.  
  2231.       case WM_DESTROY:
  2232.          OpenWindows.ulForceClose = OpenWindows.ulForceOpen = 0;
  2233.  
  2234.          QueryOpenWinButton(hwnd, IDD_SU_OPENWIN+3, &OpenWindows, OPENWIN_AREA);
  2235.          QueryOpenWinButton(hwnd, IDD_SU_OPENWIN+4, &OpenWindows, OPENWIN_KLUDGES);
  2236.          QueryOpenWinButton(hwnd, IDD_SU_OPENWIN+5, &OpenWindows, OPENWIN_BOOKMARKS);
  2237.          QueryOpenWinButton(hwnd, IDD_SU_OPENWIN+6, &OpenWindows, OPENWIN_THRL);
  2238.          QueryOpenWinButton(hwnd, IDD_SU_OPENWIN+7, &OpenWindows, OPENWIN_MSGL);
  2239.          break;
  2240.  
  2241.       default:
  2242.          break;
  2243.    }
  2244.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  2245. }
  2246.  
  2247. static void CheckOpenWinButton(HWND hwndDlg, ULONG ulID, POPENWIN pOpenWindows, ULONG ulMask)
  2248. {
  2249.    if (pOpenWindows->ulForceOpen & ulMask)
  2250.       WinCheckButton(hwndDlg, ulID, 1UL);
  2251.    else
  2252.       if (pOpenWindows->ulForceClose & ulMask)
  2253.          WinCheckButton(hwndDlg, ulID, 0UL);
  2254.       else
  2255.          WinCheckButton(hwndDlg, ulID, 2UL);
  2256.  
  2257.    return;
  2258. }
  2259.  
  2260. static void QueryOpenWinButton(HWND hwndDlg, ULONG ulID, POPENWIN pOpenWindows, ULONG ulMask)
  2261. {
  2262.    switch(WinQueryButtonCheckstate(hwndDlg, ulID))
  2263.    {
  2264.       case 0:
  2265.          pOpenWindows->ulForceClose |= ulMask;
  2266.          break;
  2267.  
  2268.       case 1:
  2269.          pOpenWindows->ulForceOpen |= ulMask;
  2270.          break;
  2271.  
  2272.       /* default: kein Flag setzen */
  2273.    }
  2274.    return;
  2275. }
  2276.  
  2277. /*----------------------------- GetPathname     -----------------------------*/
  2278. /* Holt mit Hilfe des File-Dialogs einen Pfadnamen                           */
  2279. /*---------------------------------------------------------------------------*/
  2280.  
  2281. LONG GetPathname(HWND hwndOwner, char *pchPathname)
  2282. {
  2283.    FILEDLG dlgpar;
  2284.  
  2285.    dlgpar.cbSize=sizeof(dlgpar);
  2286.    dlgpar.fl= FDS_CENTER | FDS_CUSTOM | FDS_HELPBUTTON | FDS_OPEN_DIALOG;
  2287.    dlgpar.pszTitle="File";
  2288.    dlgpar.pszOKButton="OK";
  2289.    dlgpar.pfnDlgProc=WinDefFileDlgProc;
  2290.    dlgpar.pszIType=NULL;
  2291.    dlgpar.papszITypeList=NULL;
  2292.    dlgpar.pszIDrive=NULL;
  2293.    dlgpar.papszIDriveList=NULL;
  2294.    dlgpar.hMod=hmodLang;
  2295.    strcpy(dlgpar.szFullFile,pchPathname);
  2296.    dlgpar.usDlgId=IDD_FILEDLG;
  2297.  
  2298.    WinFileDlg(HWND_DESKTOP,
  2299.               hwndOwner,
  2300.               &dlgpar);
  2301.    if (dlgpar.lReturn == DID_OK)
  2302.       strcpy(pchPathname, dlgpar.szFullFile);
  2303.    return dlgpar.lReturn;
  2304. }
  2305.  
  2306. /*-------------------------------- Modulende --------------------------------*/
  2307.  
  2308.