home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / lookups.c < prev    next >
C/C++ Source or Header  |  1997-11-08  |  45KB  |  1,138 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: LOOKUPS.C                                                          |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von: Michael Hohner            | Am: 31.12.93                    |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System: OS/2 2.x PM                                                       |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:                                                             |
  9.  |                                                                           |
  10.  |  Nodelist-Lookups und Dialoge                                             |
  11.  |                                                                           |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------+
  14.  | Moegl. Verbesserungen:                                                    |
  15.  |                                                                           |
  16.  |                                                                           |
  17.  +---------------------------------------------------------------------------+
  18.  | Geaendert: 04.01. Modem-Typen;                                            |
  19.  |            19.07. Lookup nach Adresse;                                    |
  20.  | 1995       28.05. Lookups mit Messages zentralisiert                      |
  21.  +---------------------------------------------------------------------------+
  22.  | Bemerkungen:                                                              |
  23.  +---------------------------------------------------------------------------*/
  24.  
  25. /*----------------------------- Header-Dateien ------------------------------*/
  26. #pragma strings(readonly)
  27.  
  28. #define INCL_WIN
  29. #include <os2.h>
  30. #include <stdlib.h>
  31. #include <stdio.h>
  32. #include <string.h>
  33. #include "main.h"
  34. #include "resids.h"
  35. #include "structs.h"
  36. #include "msgheader.h"
  37. #include "fltv7\fltv7.h"
  38. #include "dialogids.h"
  39. #include "areaman\areaman.h"
  40. #include "utility.h"
  41. #include "util\addrcnv.h"
  42. #include "lookups.h"
  43.  
  44. /*--------------------------------- Defines ---------------------------------*/
  45.  
  46. /*---------------------------------- Typen ----------------------------------*/
  47.  
  48. typedef struct {
  49.         MINIRECORDCORE RecordCore;
  50.         PCHAR pchSysop;
  51.         PCHAR pchAddress;
  52.         PCHAR pchSystemName;
  53.         PCHAR pchLocation;
  54.         PCHAR pchPhone;
  55.         PCHAR pchModem;
  56.         ULONG ulBaud;
  57.         ULONG ulCallCost;
  58.         ULONG ulUserCost;
  59.         PCHAR pchFlags;
  60.         ULONG ulCounter;
  61.      } LOOKUPRECORD, *PLOOKUPRECORD;
  62.  
  63. typedef struct _nodedatalist {
  64.          struct _nodedatalist *next;
  65.          NODEDATA NodeData;
  66.       } NODEDATALIST, *PNODEDATALIST;
  67.  
  68. /*---------------------------- Globale Variablen ----------------------------*/
  69.  
  70. extern HAB anchor;
  71. extern HMODULE hmodLang;
  72. static PFNWP OldLookupContainerProc;
  73.  
  74. /*--------------------------- Funktionsprototypen ---------------------------*/
  75.  
  76. static MRESULT EXPENTRY NewLookupContainerProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  77. static void CleanupLookup(HWND hwndCnr);
  78. static void LookupErrorMessage(HWND hwndOwner, char *pchErrDomain, int iErrNr);
  79.  
  80. /*----------------------- interne Funktionsprototypen -----------------------*/
  81.  
  82.  
  83. /*═══════════════════════════════════════════════════════════════════════════╗
  84.  ║ Funktionsname: LookupProc                                                 ║
  85.  ╟───────────────────────────────────────────────────────────────────────────╢
  86.  ║ Beschreibung: Auswahl-Dialog beim Nodelist-Lookup                         ║
  87.  ║                                                                           ║
  88.  ╟───────────────────────────────────────────────────────────────────────────╢
  89.  ║ Parameter: (Window-Procedure)                                             ║
  90.  ║                                                                           ║
  91.  ╟───────────────────────────────────────────────────────────────────────────╢
  92.  ║ Rückgabewerte: MRESULT                                                    ║
  93.  ║                                                                           ║
  94.  ╟───────────────────────────────────────────────────────────────────────────╢
  95.  ║ Sonstiges:                                                                ║
  96.  ║                                                                           ║
  97.  ╚═══════════════════════════════════════════════════════════════════════════*/
  98.  
  99. MRESULT EXPENTRY LookupProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  100. {
  101.    extern WINDOWPOSITIONS windowpositions;
  102.    extern WINDOWFONTS windowfonts;
  103.    extern WINDOWCOLORS windowcolors;
  104.    extern DIRTYFLAGS dirtyflags;
  105.    extern LOOKUPOPTIONS lookupoptions;
  106.    extern HWND hwndhelp;
  107.    static LOOKUPPAR *pLookupPar;
  108.    int i;
  109.    PFIELDINFO pFieldInfo, pFirstFieldInfo, pSeparator=NULL;
  110.    FIELDINFOINSERT FieldInfoInsert;
  111.    CNRINFO CnrInfo;
  112.    PLOOKUPRECORD pRecord, pFirstRecord;
  113.    RECORDINSERT RecordInsert;
  114.    HWND hwndCnr;
  115.    static char pchTitleSysop[50];
  116.    static char pchTitleAddress[50];
  117.    static char pchTitleSystem[50];
  118.    static char pchTitleLocation[50];
  119.    static char pchTitlePhone[50];
  120.    static char pchTitleModem[50];
  121.    static char pchTitleBaud[50];
  122.    static char pchTitleCallcost[50];
  123.    static char pchTitleUsercost[50];
  124.    static char pchTitleFlags[50];
  125.    static char pchTitleContainer[80];
  126.    BOOL bTemp;
  127.    MRESULT resultbuf;
  128.  
  129.    switch(message)
  130.    {
  131.       case WM_INITDLG:
  132.          pLookupPar=(LOOKUPPAR*) mp2;
  133.          WinAssociateHelpInstance(hwndhelp, parent);
  134.  
  135.          pchTitleContainer[0] = 0;
  136.          LoadString(IDST_LU_TITLE, 45, pchTitleContainer);
  137.          strcat(pchTitleContainer, pLookupPar->pchName);
  138.  
  139.          WinCheckButton(parent, IDD_LOOKUP+5, lookupoptions.bBrief);
  140.  
  141.          hwndCnr=WinWindowFromID(parent, IDD_LOOKUP+3);
  142.          OldLookupContainerProc=WinSubclassWindow(hwndCnr, NewLookupContainerProc);
  143.  
  144.          SetFont(hwndCnr, windowfonts.lookupfont);
  145.          SetForeground(hwndCnr, &windowcolors.lookupfore);
  146.          SetBackground(hwndCnr, &windowcolors.lookupback);
  147.  
  148.          /* Felder des Containers vorbereiten */
  149.          pFirstFieldInfo=(PFIELDINFO)SendMsg(hwndCnr, CM_ALLOCDETAILFIELDINFO,
  150.                                                 MPFROMLONG(10), NULL);
  151.  
  152.          pFieldInfo=pFirstFieldInfo;
  153.  
  154.          pFieldInfo->cb=sizeof(FIELDINFO);
  155.          pFieldInfo->flData=CFA_STRING | CFA_HORZSEPARATOR | CFA_SEPARATOR;
  156.          pFieldInfo->flTitle=0;
  157.          LoadString(IDST_LU_SYSOP, 50, pchTitleSysop);
  158.          pFieldInfo->pTitleData= pchTitleSysop;
  159.          pFieldInfo->offStruct= FIELDOFFSET(LOOKUPRECORD, pchSysop);
  160.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  161.  
  162.          pFieldInfo->cb=sizeof(FIELDINFO);
  163.          pFieldInfo->flData=CFA_STRING | CFA_HORZSEPARATOR;
  164.          pFieldInfo->flTitle=0;
  165.          LoadString(IDST_LU_ADDRESS, 50, pchTitleAddress);
  166.          pFieldInfo->pTitleData= pchTitleAddress;
  167.          pFieldInfo->offStruct= FIELDOFFSET(LOOKUPRECORD, pchAddress);
  168.          pSeparator=pFieldInfo;
  169.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  170.  
  171.          pFieldInfo->cb=sizeof(FIELDINFO);
  172.          pFieldInfo->flData=CFA_STRING | CFA_HORZSEPARATOR | CFA_SEPARATOR;
  173.          pFieldInfo->flTitle=0;
  174.          LoadString(IDST_LU_SYSTEM, 50, pchTitleSystem);
  175.          pFieldInfo->pTitleData= pchTitleSystem;
  176.          pFieldInfo->offStruct= FIELDOFFSET(LOOKUPRECORD, pchSystemName);
  177.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  178.  
  179.          pFieldInfo->cb=sizeof(FIELDINFO);
  180.          pFieldInfo->flData=CFA_STRING | CFA_HORZSEPARATOR | CFA_SEPARATOR |
  181.                             ((lookupoptions.bBrief)?(CFA_INVISIBLE):0);
  182.          pFieldInfo->flTitle=0;
  183.          LoadString(IDST_LU_LOCATION, 50, pchTitleLocation);
  184.          pFieldInfo->pTitleData= pchTitleLocation;
  185.          pFieldInfo->offStruct= FIELDOFFSET(LOOKUPRECORD, pchLocation);
  186.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  187.  
  188.          pFieldInfo->cb=sizeof(FIELDINFO);
  189.          pFieldInfo->flData=CFA_STRING | CFA_HORZSEPARATOR | CFA_SEPARATOR |
  190.                             ((lookupoptions.bBrief)?(CFA_INVISIBLE):0);
  191.          pFieldInfo->flTitle=0;
  192.          LoadString(IDST_LU_PHONE, 50, pchTitlePhone);
  193.          pFieldInfo->pTitleData= pchTitlePhone;
  194.          pFieldInfo->offStruct= FIELDOFFSET(LOOKUPRECORD, pchPhone);
  195.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  196.  
  197.          pFieldInfo->cb=sizeof(FIELDINFO);
  198.          pFieldInfo->flData=CFA_STRING | CFA_HORZSEPARATOR | CFA_SEPARATOR;
  199.          pFieldInfo->flTitle=0;
  200.          LoadString(IDST_LU_MODEM, 50, pchTitleModem);
  201.          pFieldInfo->pTitleData= pchTitleModem;
  202.          pFieldInfo->offStruct= FIELDOFFSET(LOOKUPRECORD, pchModem);
  203.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  204.  
  205.          pFieldInfo->cb=sizeof(FIELDINFO);
  206.          pFieldInfo->flData=CFA_ULONG | CFA_HORZSEPARATOR | CFA_SEPARATOR |
  207.                             CFA_RIGHT | ((lookupoptions.bBrief)?(CFA_INVISIBLE):0);
  208.          pFieldInfo->flTitle=0;
  209.          LoadString(IDST_LU_BAUD, 50, pchTitleBaud);
  210.          pFieldInfo->pTitleData= pchTitleBaud;
  211.          pFieldInfo->offStruct= FIELDOFFSET(LOOKUPRECORD, ulBaud);
  212.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  213.  
  214.          pFieldInfo->cb=sizeof(FIELDINFO);
  215.          pFieldInfo->flData=CFA_ULONG | CFA_HORZSEPARATOR | CFA_SEPARATOR | CFA_RIGHT |
  216.                             ((lookupoptions.bBrief)?(CFA_INVISIBLE):0);
  217.          pFieldInfo->flTitle=0;
  218.          LoadString(IDST_LU_CALLCOST, 50, pchTitleCallcost);
  219.          pFieldInfo->pTitleData= pchTitleCallcost;
  220.          pFieldInfo->offStruct= FIELDOFFSET(LOOKUPRECORD, ulCallCost);
  221.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  222.  
  223.          pFieldInfo->cb=sizeof(FIELDINFO);
  224.          pFieldInfo->flData=CFA_ULONG | CFA_HORZSEPARATOR | CFA_SEPARATOR | CFA_RIGHT |
  225.                             ((lookupoptions.bBrief)?(CFA_INVISIBLE):0);
  226.          pFieldInfo->flTitle=0;
  227.          LoadString(IDST_LU_USERCOST, 50, pchTitleUsercost);
  228.          pFieldInfo->pTitleData= pchTitleUsercost;
  229.          pFieldInfo->offStruct= FIELDOFFSET(LOOKUPRECORD, ulUserCost);
  230.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  231.  
  232.          pFieldInfo->cb=sizeof(FIELDINFO);
  233.          pFieldInfo->flData=CFA_STRING | CFA_HORZSEPARATOR | CFA_SEPARATOR;
  234.          pFieldInfo->flTitle=0;
  235.          LoadString(IDST_LU_FLAGS, 50, pchTitleFlags);
  236.          pFieldInfo->pTitleData= pchTitleFlags;
  237.          pFieldInfo->offStruct= FIELDOFFSET(LOOKUPRECORD, pchFlags);
  238.  
  239.          /* Felder des Containers einfuegen */
  240.          FieldInfoInsert.cb=sizeof(FIELDINFOINSERT);
  241.          FieldInfoInsert.pFieldInfoOrder=(PFIELDINFO) CMA_FIRST;
  242.          FieldInfoInsert.fInvalidateFieldInfo=TRUE;
  243.          FieldInfoInsert.cFieldInfoInsert=10;
  244.  
  245.          SendMsg(hwndCnr, CM_INSERTDETAILFIELDINFO,
  246.                     pFirstFieldInfo, &FieldInfoInsert);
  247.  
  248.          /* Container-Attribute setzen */
  249.          CnrInfo.cb=sizeof(CNRINFO);
  250.          CnrInfo.pFieldInfoLast=pSeparator;
  251.          CnrInfo.pszCnrTitle = pchTitleContainer;
  252.          CnrInfo.flWindowAttr=CV_DETAIL | CA_DETAILSVIEWTITLES | CA_CONTAINERTITLE | CA_TITLEREADONLY |
  253.                               CA_TITLESEPARATOR;
  254.          CnrInfo.xVertSplitbar=lookupoptions.lSplitBar;
  255.  
  256.          SendMsg(hwndCnr, CM_SETCNRINFO, &CnrInfo,
  257.                     MPFROMLONG(CMA_PFIELDINFOLAST | CMA_FLWINDOWATTR | CMA_XVERTSPLITBAR | CMA_CNRTITLE));
  258.  
  259.          /* Elemente einfuegen */
  260.  
  261.          pFirstRecord=(PLOOKUPRECORD)SendMsg(hwndCnr, CM_ALLOCRECORD,
  262.                                                 MPFROMLONG(sizeof(LOOKUPRECORD)-sizeof(MINIRECORDCORE)),
  263.                                                 MPFROMLONG(pLookupPar->iCountNodes));
  264.          pRecord=pFirstRecord;
  265.  
  266.          for (i=0; i<pLookupPar->iCountNodes; i++)
  267.          {
  268.             pRecord->pchSysop= pLookupPar->pNodes[i].SysopName;
  269.             pRecord->pchAddress=malloc(LEN_5DADDRESS+1);
  270.             if (pLookupPar->pNodes[i].Address.usPoint)
  271.                sprintf(pRecord->pchAddress, "%d:%d/%d.%d", pLookupPar->pNodes[i].Address.usZone,
  272.                                                pLookupPar->pNodes[i].Address.usNet,
  273.                                                pLookupPar->pNodes[i].Address.usNode,
  274.                                                pLookupPar->pNodes[i].Address.usPoint);
  275.             else
  276.                sprintf(pRecord->pchAddress, "%d:%d/%d", pLookupPar->pNodes[i].Address.usZone,
  277.                                             pLookupPar->pNodes[i].Address.usNet,
  278.                                             pLookupPar->pNodes[i].Address.usNode);
  279.             pRecord->pchSystemName= pLookupPar->pNodes[i].SystemName;
  280.             pRecord->pchPhone= pLookupPar->pNodes[i].PhoneNr;
  281.             pRecord->pchLocation= pLookupPar->pNodes[i].Location;
  282.             pRecord->ulBaud= pLookupPar->pNodes[i].BaudRate;
  283.             pRecord->ulUserCost= pLookupPar->pNodes[i].UserCost;
  284.             pRecord->ulCallCost= pLookupPar->pNodes[i].CallCost;
  285.  
  286.             pRecord->pchFlags=malloc(30);
  287.             NLFlagsToString(&pLookupPar->pNodes[i], pRecord->pchFlags);
  288.  
  289.             pRecord->pchModem= malloc(MAX_MODEMTYPES*(LEN_MODEMTYPE+2)+1);
  290.             NLModemToString(pLookupPar->pNodes[i].ModemType, pRecord->pchModem);
  291.  
  292.             pRecord->ulCounter=i;
  293.  
  294.             pRecord=(PLOOKUPRECORD)pRecord->RecordCore.preccNextRecord;
  295.          }
  296.  
  297.          RecordInsert.cb=sizeof(RECORDINSERT);
  298.          RecordInsert.pRecordOrder=(PRECORDCORE) CMA_FIRST;
  299.          RecordInsert.pRecordParent=NULL;
  300.          RecordInsert.fInvalidateRecord=TRUE;
  301.          RecordInsert.zOrder=CMA_TOP;
  302.          RecordInsert.cRecordsInsert=pLookupPar->iCountNodes;
  303.  
  304.          SendMsg(hwndCnr, CM_INSERTRECORD, pFirstRecord, &RecordInsert);
  305.  
  306.          RestoreWinPos(parent, &windowpositions.lookuppos, TRUE, TRUE);
  307.          break;
  308.  
  309.       case WM_QUERYTRACKINFO:
  310.          {
  311.             SWP swp;
  312.  
  313.             /* Default-Werte aus Original-Prozedur holen */
  314.             resultbuf=WinDefDlgProc(parent,message,mp1,mp2);
  315.  
  316.             WinQueryWindowPos(WinWindowFromID(parent, IDD_LOOKUP+5),
  317.                               &swp);
  318.  
  319.             /* Minimale Fenstergroesse einstellen */
  320.             ((PTRACKINFO)mp2)->ptlMinTrackSize.x=swp.x+swp.cx+5;
  321.             ((PTRACKINFO)mp2)->ptlMinTrackSize.y=200;
  322.          }
  323.          return resultbuf;
  324.  
  325.       case WM_ADJUSTFRAMEPOS:
  326.          if (((PSWP)mp1)->fl & (SWP_SIZE|SWP_MAXIMIZE|SWP_MINIMIZE|SWP_RESTORE))
  327.          {
  328.             SWP swp;
  329.             RECTL rectl;
  330.  
  331.             rectl.xLeft=0;
  332.             rectl.xRight=((PSWP)mp1)->cx;
  333.             rectl.yBottom=0;
  334.             rectl.yTop=((PSWP)mp1)->cy;
  335.  
  336.             CalcClientRect(anchor, parent, &rectl);
  337.             WinQueryWindowPos(WinWindowFromID(parent, DID_OK), &swp);
  338.             rectl.yBottom += swp.y + swp.cy;
  339.             WinSetWindowPos(WinWindowFromID(parent, IDD_LOOKUP+3),
  340.                             NULLHANDLE,
  341.                             rectl.xLeft, rectl.yBottom,
  342.                             rectl.xRight-rectl.xLeft, rectl.yTop-rectl.yBottom,
  343.                             SWP_MOVE | SWP_SIZE);
  344.          }
  345.          break;
  346.  
  347.       case WM_COMMAND:
  348.          if (SHORT1FROMMP(mp1)==DID_OK)
  349.          {
  350.             /* Auswahl abfragen */
  351.             pRecord=(PLOOKUPRECORD)WinSendDlgItemMsg(parent, IDD_LOOKUP+3,
  352.                                      CM_QUERYRECORDEMPHASIS,
  353.                                      MPFROMP(CMA_FIRST),
  354.                                      MPFROMSHORT(CRA_CURSORED));
  355.             pLookupPar->ulSelected=pRecord->ulCounter;
  356.          }
  357.          break;
  358.  
  359.       case WM_CONTROL:
  360.          switch (SHORT1FROMMP(mp1))
  361.          {
  362.             case IDD_LOOKUP+3:
  363.                if (SHORT2FROMMP(mp1)==CN_ENTER)
  364.                {
  365.                   if (((PNOTIFYRECORDENTER)mp2)->pRecord)
  366.                   {
  367.                      pLookupPar->ulSelected=((PLOOKUPRECORD)((PNOTIFYRECORDENTER)mp2)->pRecord)->ulCounter;
  368.                      WinDismissDlg(parent, DID_OK);
  369.                   }
  370.                }
  371.                break;
  372.  
  373.             case IDD_LOOKUP+5:
  374.                if (SHORT2FROMMP(mp1)==BN_CLICKED ||
  375.                    SHORT2FROMMP(mp1)==BN_DBLCLICKED)
  376.                {
  377.                   BOOL bBrief;
  378.  
  379.                   bBrief=WinQueryButtonCheckstate(parent, IDD_LOOKUP+5);
  380.  
  381.                   pFieldInfo=(PFIELDINFO)WinSendDlgItemMsg(parent, IDD_LOOKUP+3,
  382.                                           CM_QUERYDETAILFIELDINFO,
  383.                                           NULL, MPFROMSHORT(CMA_FIRST));
  384.  
  385.                   pFieldInfo=pFieldInfo->pNextFieldInfo;
  386.                   pFieldInfo=pFieldInfo->pNextFieldInfo;
  387.                   pFieldInfo=pFieldInfo->pNextFieldInfo;
  388.                   /* Location, Phone */
  389.                   if (bBrief)
  390.                      pFieldInfo->flData |= CFA_INVISIBLE;
  391.                   else
  392.                      pFieldInfo->flData &= ~CFA_INVISIBLE;
  393.                   pFieldInfo=pFieldInfo->pNextFieldInfo;
  394.                   if (bBrief)
  395.                      pFieldInfo->flData |= CFA_INVISIBLE;
  396.                   else
  397.                      pFieldInfo->flData &= ~CFA_INVISIBLE;
  398.                   pFieldInfo=pFieldInfo->pNextFieldInfo;
  399.                   /* Baud */
  400.                   pFieldInfo=pFieldInfo->pNextFieldInfo;
  401.                   if (bBrief)
  402.                      pFieldInfo->flData |= CFA_INVISIBLE;
  403.                   else
  404.                      pFieldInfo->flData &= ~CFA_INVISIBLE;
  405.                   pFieldInfo=pFieldInfo->pNextFieldInfo;
  406.                   /* Callcost, Usercost */
  407.                   if (bBrief)
  408.                      pFieldInfo->flData |= CFA_INVISIBLE;
  409.                   else
  410.                      pFieldInfo->flData &= ~CFA_INVISIBLE;
  411.                   pFieldInfo=pFieldInfo->pNextFieldInfo;
  412.                   if (bBrief)
  413.                      pFieldInfo->flData |= CFA_INVISIBLE;
  414.                   else
  415.                      pFieldInfo->flData &= ~CFA_INVISIBLE;
  416.                   WinSendDlgItemMsg(parent, IDD_LOOKUP+3,
  417.                                     CM_INVALIDATEDETAILFIELDINFO,
  418.                                     NULL, NULL);
  419.                }
  420.                break;
  421.  
  422.             default:
  423.                break;
  424.          }
  425.          break;
  426.  
  427.       case WM_CLOSE:
  428.       case WM_DESTROY:
  429.          CleanupLookup(WinWindowFromID(parent, IDD_LOOKUP+3));
  430.          QueryWinPos(parent, &windowpositions.lookuppos);
  431.          QueryFont(WinWindowFromID(parent, IDD_LOOKUP+3), windowfonts.lookupfont);
  432.          QueryForeground(WinWindowFromID(parent, IDD_LOOKUP+3), &windowcolors.lookupfore);
  433.          QueryBackground(WinWindowFromID(parent, IDD_LOOKUP+3), &windowcolors.lookupback);
  434.          bTemp=WinQueryButtonCheckstate(parent, IDD_LOOKUP+5);
  435.          if (lookupoptions.bBrief != bTemp)
  436.          {
  437.             lookupoptions.bBrief = bTemp;
  438.             dirtyflags.lookupdirty=TRUE;
  439.          }
  440.          WinSendDlgItemMsg(parent, IDD_LOOKUP+3, CM_QUERYCNRINFO,
  441.                            &CnrInfo, MPFROMLONG(sizeof(CNRINFO)));
  442.  
  443.          if (lookupoptions.lSplitBar != CnrInfo.xVertSplitbar)
  444.          {
  445.             lookupoptions.lSplitBar = CnrInfo.xVertSplitbar;
  446.             dirtyflags.lookupdirty=TRUE;
  447.          }
  448.          WinAssociateHelpInstance(hwndhelp, WinQueryWindow(parent, QW_OWNER));
  449.          break;
  450.  
  451.       default:
  452.          break;
  453.    }
  454.    return WinDefDlgProc(parent, message, mp1, mp2);
  455. }
  456.  
  457. /*═══════════════════════════════════════════════════════════════════════════╗
  458.  ║ Funktionsname: CleanupLookup                                              ║
  459.  ╟───────────────────────────────────────────────────────────────────────────╢
  460.  ║ Beschreibung: Raeumt den Container fuer den Lookup auf                    ║
  461.  ╟───────────────────────────────────────────────────────────────────────────╢
  462.  ║ Parameter: hwndCnr: Window-Handle des Containers                          ║
  463.  ╟───────────────────────────────────────────────────────────────────────────╢
  464.  ║ Rückgabewerte: keine                                                      ║
  465.  ╟───────────────────────────────────────────────────────────────────────────╢
  466.  ║ Sonstiges:                                                                ║
  467.  ║                                                                           ║
  468.  ╚═══════════════════════════════════════════════════════════════════════════*/
  469.  
  470. static void CleanupLookup(HWND hwndCnr)
  471. {
  472.    PLOOKUPRECORD pRecord;
  473.  
  474.    while(pRecord=(PLOOKUPRECORD)SendMsg(hwndCnr, CM_QUERYRECORD,
  475.                                   NULL, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER)))
  476.    {
  477.       free(pRecord->pchAddress);
  478.       free(pRecord->pchFlags);
  479.       SendMsg(hwndCnr, CM_REMOVERECORD, &pRecord,
  480.                  MPFROM2SHORT(1, CMA_FREE));
  481.    }
  482.  
  483.    return;
  484. }
  485.  
  486. /*═══════════════════════════════════════════════════════════════════════════╗
  487.  ║ Funktionsname: LookupNodelists                                            ║
  488.  ╟───────────────────────────────────────────────────────────────────────────╢
  489.  ║ Beschreibung: Durchsucht die Nodelisten nach dem gesuchten Namen, liefert ║
  490.  ║               die Eintraege zurueck                                       ║
  491.  ╟───────────────────────────────────────────────────────────────────────────╢
  492.  ║ Parameter: pchName: Sysop-Name                                            ║
  493.  ║            pDomains: Domain-Liste                                         ║
  494.  ║            ppResults: Erzeugtes Ergebnis-Array                            ║
  495.  ║            errdomain: Domain-Name bei Fehler                              ║
  496.  ╟───────────────────────────────────────────────────────────────────────────╢
  497.  ║ Rückgabewerte: 0  OK, nichts gefunden                                     ║
  498.  ║                >0 Anzahl der gefundenen Einträge                          ║
  499.  ║                -1 Fehler beim Oeffenen des Index-Files                    ║
  500.  ║                -2 Fehler beim Oeffenen des Daten-Files                    ║
  501.  ║                -3 Fehler beim Lesen des Index-Files                       ║
  502.  ║                -4 Fehler beim Lesen des Daten-Files                       ║
  503.  ║                -5 Kein Speicher                                           ║
  504.  ║                -6 Ungültiges Handle                                       ║
  505.  ║                                                                           ║
  506.  ╟───────────────────────────────────────────────────────────────────────────╢
  507.  ║ Sonstiges:                                                                ║
  508.  ║                                                                           ║
  509.  ╚═══════════════════════════════════════════════════════════════════════════*/
  510.  
  511. int LookupNodelists(char *pchName, PDOMAINS pDomain, PNODEDATA *ppResults, char *errdomain)
  512. {
  513.    int foundentries=0;
  514.    HV7LOOKUP hLookup;
  515.    NODEDATA NodeData;
  516.    ULONG rc;
  517.    char *p1, *p2;
  518.    char pchNLName[LEN_USERNAME+5];
  519.    PDOMAINS pTemp;
  520.    PNODEDATALIST pNodeDataList=NULL, pThisNode=NULL;
  521.  
  522.    if (strlen(pchName)<3)
  523.       return 0;
  524.  
  525.    p1=pchName;
  526.    while(*p1)   /* Ende des Strings suchen */
  527.       p1++;
  528.  
  529.    while(p1 >= pchName && *p1 != ' ')  /* letztes Leerzeichen suchen */
  530.       p1--;
  531.  
  532.    if (p1 >= pchName) /* Leerzeichen gefunden */
  533.    {
  534.       *p1='\0';
  535.  
  536.       p1++;
  537.  
  538.       strcpy(pchNLName, p1);
  539.       strcat(pchNLName, ", ");
  540.  
  541.       p2=pchName;
  542.       while(*p2 && *p2==' ')  /* Anfang des Vornamens suchen */
  543.          p2++;
  544.  
  545.       strcat(pchNLName, p2);
  546.    }
  547.    else
  548.       strcpy(pchNLName, pchName);
  549.  
  550.  
  551.    pTemp=pDomain;
  552.  
  553.    while(pTemp)
  554.    {
  555.       if (pTemp->indexfile[0] && pTemp->nodelistfile[0])
  556.       {
  557.          switch(FLTV7OpenSearch(&hLookup, pchNLName, pTemp->indexfile,
  558.                                 pTemp->nodelistfile, V7SEARCHTYPE_NAME))
  559.          {
  560.             case V7ERR_IDXOPENERR:
  561.                strcpy(errdomain, pTemp->domainname);
  562.                FLTV7CloseSearch(hLookup);
  563.                return -1;
  564.  
  565.             case V7ERR_DATOPENERR:
  566.                strcpy(errdomain, pTemp->domainname);
  567.                FLTV7CloseSearch(hLookup);
  568.                return -2;
  569.  
  570.             case V7ERR_IDXREADERR:
  571.                strcpy(errdomain, pTemp->domainname);
  572.                FLTV7CloseSearch(hLookup);
  573.                return -3;
  574.  
  575.             case V7ERR_DATREADERR:
  576.                strcpy(errdomain, pTemp->domainname);
  577.                FLTV7CloseSearch(hLookup);
  578.                return -4;
  579.  
  580.             case V7ERR_NOMEM:
  581.                strcpy(errdomain, pTemp->domainname);
  582.                FLTV7CloseSearch(hLookup);
  583.                return -5;
  584.  
  585.             case V7ERR_INVHANDLE:
  586.                strcpy(errdomain, pTemp->domainname);
  587.                FLTV7CloseSearch(hLookup);
  588.                return -6;
  589.  
  590.             default:
  591.                break;
  592.          }
  593.          while (!(rc=FLTV7SearchNext(hLookup, &NodeData)))
  594.          {
  595.             /* Eintrag gefunden */
  596.             if (pNodeDataList==NULL)
  597.             {
  598.                pNodeDataList=malloc(sizeof(NODEDATALIST));
  599.                memcpy(&pNodeDataList->NodeData, &NodeData, sizeof(NODEDATA));
  600.                pNodeDataList->next=NULL;
  601.                pThisNode=pNodeDataList;
  602.             }
  603.             else
  604.             {
  605.                pThisNode->next=malloc(sizeof(NODEDATALIST));
  606.                pThisNode=pThisNode->next;
  607.                memcpy(&pThisNode->NodeData, &NodeData, sizeof(NODEDATA));
  608.                pThisNode->next=NULL;
  609.             }
  610.             foundentries++;
  611.          }
  612.          switch(rc)
  613.          {
  614.             case V7ERR_IDXREADERR:
  615.                strcpy(errdomain, pTemp->domainname);
  616.                FLTV7CloseSearch(hLookup);
  617.                foundentries=-3;
  618.                break;
  619.  
  620.             case V7ERR_DATREADERR:
  621.                strcpy(errdomain, pTemp->domainname);
  622.                FLTV7CloseSearch(hLookup);
  623.                foundentries=-4;
  624.                break;
  625.  
  626.             case V7ERR_INVHANDLE:
  627.                strcpy(errdomain, pTemp->domainname);
  628.                FLTV7CloseSearch(hLookup);
  629.                foundentries=-6;
  630.                break;
  631.  
  632.             default:
  633.                break;
  634.          }
  635.          FLTV7CloseSearch(hLookup);
  636.          if (foundentries <0)
  637.          {
  638.             /* Ergebnisse verwerfen */
  639.             while(pNodeDataList)
  640.             {
  641.                pThisNode=pNodeDataList->next;
  642.                free(pNodeDataList);
  643.                pNodeDataList=pThisNode;
  644.             }
  645.             break;
  646.          }
  647.       }
  648.       pTemp=pTemp->next;
  649.    }
  650.  
  651.    if (foundentries > 0)
  652.    {
  653.       ULONG i=0;
  654.  
  655.       *ppResults=malloc(sizeof(NODEDATA) * foundentries);
  656.       while(pNodeDataList)
  657.       {
  658.          memcpy(&(*ppResults)[i], &pNodeDataList->NodeData, sizeof(NODEDATA));
  659.          pThisNode=pNodeDataList->next;
  660.          free(pNodeDataList);
  661.          pNodeDataList=pThisNode;
  662.          i++;
  663.       }
  664.    }
  665.    else
  666.       *ppResults=NULL;
  667.  
  668.    return foundentries;
  669. }
  670.  
  671. /*═══════════════════════════════════════════════════════════════════════════╗
  672.  ║ Funktionsname: LookupAddress                                              ║
  673.  ╟───────────────────────────────────────────────────────────────────────────╢
  674.  ║ Beschreibung: Durchsucht die Nodelisten nach der gesuchten Adresse,       ║
  675.  ║               liefert die Eintraege zurueck                               ║
  676.  ╟───────────────────────────────────────────────────────────────────────────╢
  677.  ║ Parameter: pchAddress: gesuchte Adresse                                   ║
  678.  ║            pDomains: Domain-Liste                                         ║
  679.  ║            ppResults: Erzeugtes Ergebnis-Array                            ║
  680.  ║            errdomain: Domain-Name bei Fehler                              ║
  681.  ╟───────────────────────────────────────────────────────────────────────────╢
  682.  ║ Rückgabewerte: 0  OK, nichts gefunden                                     ║
  683.  ║                >0 Anzahl der gefundenen Einträge                          ║
  684.  ║                -1 Fehler beim Oeffenen des Index-Files                    ║
  685.  ║                -2 Fehler beim Oeffenen des Daten-Files                    ║
  686.  ║                -3 Fehler beim Lesen des Index-Files                       ║
  687.  ║                -4 Fehler beim Lesen des Daten-Files                       ║
  688.  ║                -5 Kein Speicher                                           ║
  689.  ║                -6 Ungültiges Handle                                       ║
  690.  ║                                                                           ║
  691.  ╟───────────────────────────────────────────────────────────────────────────╢
  692.  ║ Sonstiges:                                                                ║
  693.  ║                                                                           ║
  694.  ╚═══════════════════════════════════════════════════════════════════════════*/
  695.  
  696. int LookupAddress(char *pchAddress, PDOMAINS pDomain, PNODEDATA *ppResults, char *errdomain)
  697. {
  698.    int foundentries=0;
  699.    HV7LOOKUP hLookup;
  700.    NODEDATA NodeData;
  701.    ULONG rc;
  702.    PDOMAINS pTemp;
  703.    PNODEDATALIST pNodeDataList=NULL, pThisNode=NULL;
  704.  
  705.    if (!*pchAddress)
  706.       return 0;
  707.  
  708.    pTemp=pDomain;
  709.  
  710.    while(pTemp)
  711.    {
  712.       if (pTemp->nodelistfile[0])
  713.       {
  714.          /* Index-Dateiname erzeugen */
  715.          char drive[_MAX_DRIVE];
  716.          char   dir[_MAX_DIR];
  717.          char fname[_MAX_FNAME];
  718.          char   ext[_MAX_EXT];
  719.          char indexfile[LEN_PATHNAME+1];
  720.  
  721.          _splitpath(pTemp->nodelistfile, drive, dir, fname, ext);
  722.          strcpy(ext, ".NDX");
  723.          _makepath(indexfile, drive, dir, fname, ext);
  724.  
  725.          switch(FLTV7OpenSearch(&hLookup, pchAddress, indexfile,
  726.                                 pTemp->nodelistfile, V7SEARCHTYPE_ADDRESS))
  727.          {
  728.             case V7ERR_IDXOPENERR:
  729.                strcpy(errdomain, pTemp->domainname);
  730.                FLTV7CloseSearch(hLookup);
  731.                return -1;
  732.  
  733.             case V7ERR_DATOPENERR:
  734.                strcpy(errdomain, pTemp->domainname);
  735.                FLTV7CloseSearch(hLookup);
  736.                return -2;
  737.  
  738.             case V7ERR_IDXREADERR:
  739.                strcpy(errdomain, pTemp->domainname);
  740.                FLTV7CloseSearch(hLookup);
  741.                return -3;
  742.  
  743.             case V7ERR_DATREADERR:
  744.                strcpy(errdomain, pTemp->domainname);
  745.                FLTV7CloseSearch(hLookup);
  746.                return -4;
  747.  
  748.             case V7ERR_NOMEM:
  749.                strcpy(errdomain, pTemp->domainname);
  750.                FLTV7CloseSearch(hLookup);
  751.                return -5;
  752.  
  753.             case V7ERR_INVHANDLE:
  754.                strcpy(errdomain, pTemp->domainname);
  755.                FLTV7CloseSearch(hLookup);
  756.                return -6;
  757.  
  758.             default:
  759.                break;
  760.          }
  761.          if (!(rc=FLTV7SearchNext(hLookup, &NodeData)))
  762.          {
  763.             /* Eintrag gefunden */
  764.             if (pNodeDataList==NULL)
  765.             {
  766.                pNodeDataList=malloc(sizeof(NODEDATALIST));
  767.                memcpy(&pNodeDataList->NodeData, &NodeData, sizeof(NODEDATA));
  768.                pNodeDataList->next=NULL;
  769.                pThisNode=pNodeDataList;
  770.             }
  771.             else
  772.             {
  773.                pThisNode->next=malloc(sizeof(NODEDATALIST));
  774.                pThisNode=pThisNode->next;
  775.                memcpy(&pThisNode->NodeData, &NodeData, sizeof(NODEDATA));
  776.                pThisNode->next=NULL;
  777.             }
  778.  
  779.             foundentries++;
  780.          }
  781.          switch(rc)
  782.          {
  783.             case V7ERR_IDXREADERR:
  784.                strcpy(errdomain, pTemp->domainname);
  785.                FLTV7CloseSearch(hLookup);
  786.                foundentries=-3;
  787.                break;
  788.  
  789.             case V7ERR_DATREADERR:
  790.                strcpy(errdomain, pTemp->domainname);
  791.                FLTV7CloseSearch(hLookup);
  792.                foundentries=-4;
  793.                break;
  794.  
  795.             case V7ERR_INVHANDLE:
  796.                strcpy(errdomain, pTemp->domainname);
  797.                FLTV7CloseSearch(hLookup);
  798.                foundentries=-6;
  799.                break;
  800.  
  801.             default:
  802.                break;
  803.          }
  804.          FLTV7CloseSearch(hLookup);
  805.          if (foundentries <0)
  806.          {
  807.             /* Ergebnisse verwerfen */
  808.             while(pNodeDataList)
  809.             {
  810.                pThisNode=pNodeDataList->next;
  811.                free(pNodeDataList);
  812.                pNodeDataList=pThisNode;
  813.             }
  814.             break;
  815.          }
  816.       }
  817.       pTemp=pTemp->next;
  818.    }
  819.  
  820.    if (foundentries > 0)
  821.    {
  822.       ULONG i=0;
  823.  
  824.       *ppResults=malloc(sizeof(NODEDATA) * foundentries);
  825.       while(pNodeDataList)
  826.       {
  827.          memcpy(&(*ppResults)[i], &pNodeDataList->NodeData, sizeof(NODEDATA));
  828.          pThisNode=pNodeDataList->next;
  829.          free(pNodeDataList);
  830.          pNodeDataList=pThisNode;
  831.          i++;
  832.       }
  833.    }
  834.    else
  835.       *ppResults=NULL;
  836.  
  837.    return foundentries;
  838. }
  839.  
  840. /*═══════════════════════════════════════════════════════════════════════════╗
  841.  ║ Funktionsname: NewLookupContainerProc                                     ║
  842.  ╟───────────────────────────────────────────────────────────────────────────╢
  843.  ║ Beschreibung: Neue Window-Procedure f. Container (wg. OS/2-Bug)           ║
  844.  ╟───────────────────────────────────────────────────────────────────────────╢
  845.  ║ Parameter: (Window-Procedure)                                             ║
  846.  ╟───────────────────────────────────────────────────────────────────────────╢
  847.  ║ Rückgabewerte: MRESULT                                                    ║
  848.  ╟───────────────────────────────────────────────────────────────────────────╢
  849.  ║ Sonstiges:                                                                ║
  850.  ╚═══════════════════════════════════════════════════════════════════════════*/
  851.  
  852. static MRESULT EXPENTRY NewLookupContainerProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  853. {
  854.    switch(message)
  855.    {
  856.       case DM_DRAGOVER:
  857.          DrgAccessDraginfo(mp1);
  858.          break;
  859.  
  860.       default:
  861.          break;
  862.    }
  863.    return OldLookupContainerProc(parent, message, mp1, mp2);
  864. }
  865.  
  866. char *NLFlagsToString(PNODEDATA pNodeData, PCHAR pchFlags)
  867. {
  868.    pchFlags[0]='\0';
  869.    if (pNodeData->isZC)
  870.       strcat(pchFlags, "ZC");
  871.    if (pNodeData->isRC)
  872.    {
  873.       if (pchFlags[0])
  874.          strcat(pchFlags, ", ");
  875.       strcat(pchFlags, "RC");
  876.    }
  877.    if (pNodeData->isCM)
  878.    {
  879.       if (pchFlags[0])
  880.          strcat(pchFlags, ", ");
  881.       strcat(pchFlags, "CM");
  882.    }
  883.    if (pNodeData->isMO)
  884.    {
  885.       if (pchFlags[0])
  886.          strcat(pchFlags, ", ");
  887.       strcat(pchFlags, "MO");
  888.    }
  889.    if (pNodeData->isHost)
  890.    {
  891.       if (pchFlags[0])
  892.          strcat(pchFlags, ", ");
  893.       strcat(pchFlags, "Host");
  894.    }
  895.    if (pNodeData->isHub)
  896.    {
  897.       if (pchFlags[0])
  898.          strcat(pchFlags, ", ");
  899.       strcat(pchFlags, "Hub");
  900.    }
  901.    return pchFlags;
  902. }
  903.  
  904. char *NLModemToString(ULONG ulModemType, PCHAR pchModem)
  905. {
  906.    int iType;
  907.    ULONG ulMask;
  908.    extern NODELISTOPT nodelist;
  909.  
  910.    pchModem[0]='\0';
  911.  
  912.    if (nodelist.ulOptions & MODEMFLAGS_BYTETYPE)
  913.    {
  914.       if (ulModemType >0 && ulModemType <= MAX_MODEMTYPES_BYTE)
  915.          strcpy(pchModem, nodelist.bytetypes[ulModemType-1]);
  916.    }
  917.    else
  918.       for (iType=0, ulMask=1; iType<MAX_MODEMTYPES; iType++, ulMask= ulMask<<1)
  919.       {
  920.          if (ulModemType & ulMask)
  921.          {
  922.             if (pchModem[0])
  923.                strcat(pchModem, ", ");
  924.             strcat(pchModem, nodelist.modemtype[iType]);
  925.          }
  926.       }
  927.  
  928.    return pchModem;
  929. }
  930.  
  931. /*---------------------------------------------------------------------------*/
  932. /* Funktionsname: PerformNameLookup                                          */
  933. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  934. /* Beschreibung: Fuehrt einen kompletten Namens-Lookup durch                 */
  935. /*                                                                           */
  936. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  937. /* Parameter: pchSearchName: Gesuchter Name (oder Teilname)                  */
  938. /*            hwndDlg: Owner-Window f. Messages und Dialoge                  */
  939. /*            ulFlags: Flags, s. LOOKUPS.H                                   */
  940. /*            pchFoundName: Gefundener bzw. ausgewaehlter Name               */
  941. /*            pchFoundAddress: Gefundene bzw. ausgewaehlte Adresse           */
  942. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  943. /* Rückgabewerte: TRUE:  Gefunden und/oder ausgewählt                        */
  944. /*                FALSE: nicht gefunden bzw. Auswahl abgebrochen             */
  945. /*                       (pchFoundName und pchFoundAddress werden nicht      */
  946. /*                        veraendert).                                       */
  947. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  948. /* Sonstiges: -                                                              */
  949. /*                                                                           */
  950. /*---------------------------------------------------------------------------*/
  951.  
  952. BOOL PerformNameLookup(char *pchSearchName, HWND hwndDlg, ULONG ulFlags,
  953.                        char *pchFoundName, char *pchFoundAddress)
  954. {
  955.    extern PDOMAINS domains;
  956.    PNODEDATA pFoundNodes=NULL;
  957.    char pchErrDomain[LEN_DOMAIN+1]="";
  958.    int countNodes=0;
  959.    char *pchName;
  960.    BOOL bSuccess=FALSE;
  961.  
  962.    if (domains && pchSearchName[0])
  963.    {
  964.       pchName=strdup(pchSearchName);
  965.  
  966.       switch(countNodes=LookupNodelists(pchName, domains, &pFoundNodes, pchErrDomain))
  967.       {
  968.          LOOKUPPAR LookupPar;
  969.  
  970.          /* Nix gefunden */
  971.          case 0:
  972.             break;
  973.  
  974.          case -1:
  975.          case -2:
  976.          case -3:
  977.          case -4:
  978.          case -5:
  979.          case -6:
  980.             LookupErrorMessage(hwndDlg, pchErrDomain, countNodes);
  981.             break;
  982.  
  983.          /* eine oder mehrere Adressen */
  984.          default:
  985.             if (countNodes == 1 && !(ulFlags & LOOKUP_FORCESELECT))
  986.             {
  987.                /* sofort einfügen */
  988.                NetAddrToString(pchFoundAddress, &pFoundNodes[0].Address);
  989.                strcpy(pchFoundName, pFoundNodes[0].SysopName);
  990.                bSuccess = TRUE;
  991.             }
  992.             else
  993.             {
  994.                /* Auswahldialog */
  995.                LookupPar.cb=sizeof(LOOKUPPAR);
  996.                strcpy(LookupPar.pchName, pchSearchName);
  997.                LookupPar.pNodes=pFoundNodes;
  998.                LookupPar.iCountNodes=countNodes;
  999.  
  1000.                if (WinDlgBox(HWND_DESKTOP, hwndDlg, LookupProc,
  1001.                              hmodLang, IDD_LOOKUP, &LookupPar)==DID_OK)
  1002.                {
  1003.                   NetAddrToString(pchFoundAddress, &pFoundNodes[LookupPar.ulSelected].Address);
  1004.                   strcpy(pchFoundName, pFoundNodes[LookupPar.ulSelected].SysopName);
  1005.                   bSuccess = TRUE;
  1006.                }
  1007.             }
  1008.             break;
  1009.       }
  1010.       if (pFoundNodes)
  1011.          free(pFoundNodes);
  1012.       free(pchName);
  1013.    }
  1014.    return bSuccess;
  1015. }
  1016.  
  1017. /*---------------------------------------------------------------------------*/
  1018. /* Funktionsname: PerformNodeLookup                                          */
  1019. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1020. /* Beschreibung: Fuehrt einen kompletten Nodenummern-Lookup durch            */
  1021. /*                                                                           */
  1022. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1023. /* Parameter: pchSearchAddress: Gesuchte Adresse                             */
  1024. /*            hwndDlg: Owner-Window f. Messages und Dialoge                  */
  1025. /*            pchFoundName: Gefundener Name                                  */
  1026. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1027. /* Rückgabewerte: TRUE:  Gefunden                                            */
  1028. /*                FALSE: nicht gefunden (pchFoundName wird nicht verändert)  */
  1029. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1030. /* Sonstiges: -                                                              */
  1031. /*                                                                           */
  1032. /*---------------------------------------------------------------------------*/
  1033.  
  1034. BOOL PerformNodeLookup(char *pchSearchAddress, HWND hwndDlg, char *pchFoundName)
  1035. {
  1036.    extern PDOMAINS domains;
  1037.    PNODEDATA pFoundNodes=NULL;
  1038.    char pchErrDomain[LEN_DOMAIN+1]="";
  1039.    int countNodes=0;
  1040.    BOOL bSuccess=FALSE;
  1041.  
  1042.    if (domains && pchSearchAddress[0])
  1043.    {
  1044.       switch (countNodes = LookupAddress(pchSearchAddress, domains, &pFoundNodes, pchErrDomain))
  1045.       {
  1046.          /* Nix gefunden */
  1047.          case 0:
  1048.             break;
  1049.  
  1050.          case -1:
  1051.          case -2:
  1052.          case -3:
  1053.          case -4:
  1054.          case -5:
  1055.          case -6:
  1056.             LookupErrorMessage(hwndDlg, pchErrDomain, countNodes);
  1057.             break;
  1058.  
  1059.          default:
  1060.             strcpy(pchFoundName, pFoundNodes[0].SysopName);
  1061.             bSuccess = TRUE;
  1062.             break;
  1063.       }
  1064.       if (pFoundNodes)
  1065.          free(pFoundNodes);
  1066.    }
  1067.    return bSuccess;
  1068. }
  1069.  
  1070. /*---------------------------------------------------------------------------*/
  1071. /* Funktionsname: LookupErrorMessage                                         */
  1072. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1073. /* Beschreibung: Zeigt eine Lookup-Fehlermeldung an                          */
  1074. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1075. /* Parameter: hwndOwner: Owner-Window fuer die Message-Box                   */
  1076. /*            pchErrDomain: Domain, in dem der Fehler aufgetreten ist        */
  1077. /*            iErrNr: Fehler-Nummer (-1 .. -6)                               */
  1078. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1079. /* Rückgabewerte: -                                                          */
  1080. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1081. /* Sonstiges: -                                                              */
  1082. /*---------------------------------------------------------------------------*/
  1083.  
  1084. static void LookupErrorMessage(HWND hwndOwner, char *pchErrDomain, int iErrNr)
  1085. {
  1086.    char rawmsg[200];
  1087.    char message[300];
  1088.  
  1089.    switch (iErrNr)
  1090.    {
  1091.       case -1:
  1092.          LoadString(IDST_MSG_IDXOPENERR, 200, rawmsg);
  1093.          sprintf(message, rawmsg, pchErrDomain);
  1094.          WinMessageBox(HWND_DESKTOP, hwndOwner, message, NULL, IDD_IDXOPENERR,
  1095.                        MB_OK | MB_HELP | MB_MOVEABLE | MB_ERROR);
  1096.          break;
  1097.  
  1098.       case -2:
  1099.          LoadString(IDST_MSG_DATOPENERR, 200, rawmsg);
  1100.          sprintf(message, rawmsg, pchErrDomain);
  1101.          WinMessageBox(HWND_DESKTOP, hwndOwner, message, NULL, IDD_DATOPENERR,
  1102.                        MB_OK | MB_HELP | MB_MOVEABLE | MB_ERROR);
  1103.          break;
  1104.  
  1105.       case -3:
  1106.          LoadString(IDST_MSG_IDXREADERR, 200, rawmsg);
  1107.          sprintf(message, rawmsg, pchErrDomain);
  1108.          WinMessageBox(HWND_DESKTOP, hwndOwner, message, NULL, IDD_IDXREADERR,
  1109.                        MB_OK | MB_HELP | MB_MOVEABLE | MB_ERROR);
  1110.          break;
  1111.  
  1112.       case -4:
  1113.          LoadString(IDST_MSG_DATREADERR, 200, rawmsg);
  1114.          sprintf(message, rawmsg, pchErrDomain);
  1115.          WinMessageBox(HWND_DESKTOP, hwndOwner, message, NULL, IDD_DATREADERR,
  1116.                        MB_OK | MB_HELP | MB_MOVEABLE | MB_ERROR);
  1117.          break;
  1118.  
  1119.       case -5:
  1120.          LoadString(IDST_MSG_LOOKUPMEM, 200, rawmsg);
  1121.          sprintf(message, rawmsg, pchErrDomain);
  1122.          WinMessageBox(HWND_DESKTOP, hwndOwner, message, NULL, IDD_LOOKUPMEM,
  1123.                        MB_OK | MB_HELP | MB_MOVEABLE | MB_ERROR);
  1124.          break;
  1125.  
  1126.       case -6:
  1127.          MessageBox(hwndOwner, IDST_MSG_LOOKUPHANDLE, 0, IDD_LOOKUPHANDLE,
  1128.                     MB_OK | MB_HELP);
  1129.          break;
  1130.  
  1131.       default:
  1132.          break;
  1133.    }
  1134.    return;
  1135. }
  1136.  
  1137. /*──────────────────────────────── Modulende ────────────────────────────────*/
  1138.