home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / smart21b.zip / SAMPLES / SLINK / LINK.C < prev    next >
C/C++ Source or Header  |  1994-02-18  |  24KB  |  661 lines
  1. /*************************************************************
  2. LINK.c
  3.  
  4. **************************************************************/
  5.  
  6.  
  7.  
  8. /********************* GLOBALS *******************************/
  9.  
  10. CHAR szFileName[CCHMAXPATH];    /* Holds current XR file */
  11. CHAR szXRName[MAXXRNAME+1];     /* Used to return the XR name +1 for NULL */
  12. USHORT usRetXRType;             /* Used to return selected XR Type */
  13. BOOL FILE_ISOPEN = FALSE;       /* File Open flag */
  14. BOOL FILE_CHANGED = FALSE;      /* File Changed flag */
  15. BOOL COMMAND_LINE_FILE = FALSE; /* Flag to determine if a file was on the CL */
  16. HHXRP hhp;                      /* Pointer to the heap */
  17. CHAR *szAscii,*szScratch;       /* 2 Pointer used to return misc. strings */
  18. HOLDFXR *pHoldFXR;              /* Global XR linked-list pointer          */
  19. DELETELIST *pDelList;           /* Global ptr to l-l of deleted XRs       */
  20. XRDATA ConvTable[XRTABLESIZE] = {    /* Setup the table */
  21.    { XR_LPBINARY  ,"Length preceeded hex binary\0        ",IDD_LPDATA},
  22.    { XR_LPASCII   ,"Length preceeded ascii\0             ",IDD_LPDATA},
  23.    { XR_ASCIIZ    ,"Asciiz\0                             ",IDD_ASCIIZ},
  24.    { XR_LPBITMAP  ,"Length preceeded bitmap\0            ",IDD_LPDATA},
  25.    { XR_LPMETAFILE,"Metafile\0                           ",IDD_LPDATA},
  26.    { XR_LPICON    ,"Length preceeded icon\0              ",IDD_LPDATA},
  27.    { XR_ASCIIZFN  ,"Asciiz file name of associated data\0",IDD_ASCIIZ},
  28.    { XR_ASCIIZXR  ,"Asciiz XR of associated data\0       ",IDD_ASCIIZ},
  29.    { XR_MVMT      ,"Multi value multi type field\0       ",IDD_MULTILIST},
  30.    { XR_MVST      ,"Multi value single type field\0      ",IDD_MULTILIST},
  31.    { XR_ASN1      ,"ASN.1 field\0                        ",IDD_ASCIIZ},
  32.    { 0            ,"Non conventional format\0            ",IDD_ASCIIZ}
  33.    };
  34.  
  35. /*************************************************************/
  36.  
  37. /*
  38.  * Function name: main()
  39.  *
  40.  *
  41.  */
  42.  
  43. int main(int argc, char *argv[])
  44. {
  45.    HAB          hab;
  46.    HMQ          hmq;
  47.  
  48.    if)(argc > 1)  /* If a command line file, get XRs from it */
  49.       if(ParseFileName(szFileName,argv[1]) != FILE_VALID) /* Bad file name */
  50.          *szFileName=0;
  51.       else
  52.          COMMAND_LINE_FILE = TRUE;
  53.  
  54.    /* Note:  The following 3 setup calls aren't currently checked for errors */
  55.    hab = WinInitialize(0);
  56.    hmq = WinCreateMsgQueue(hab, 0);
  57.    hhp = WinCreateHeap(0, 0, GROWSIZE, 0, 0,
  58.                           HM_MOVXRBLE | HM_VALIDSIZE | HM_VALIDFLAGS);
  59.  
  60.    WinDlgBox(HWND_DESKTOP, HWND_DESKTOP,
  61.                          MainDlgProc,NULL,IDD_MAIN,NULL);
  62.  
  63.    WinDestroyMsgQueue(hmq);
  64.    WinTerminate(hab);
  65.    return 0;
  66. }
  67.      if (WinDlgBox(HWND_DESKTOP,
  68.              hwndFrame,    /* handle of the owner         */
  69.              OpenDlg,      /* dialog procedure address    */
  70.              NULLHANDLE,   /* location of dialog resource */
  71.              IDD_OPEN,     /* resource identifier         */
  72.              NULL)) {      /* application-specific data   */
  73.  
  74.  
  75. /*
  76.  * Function name: MainDlgProc()
  77.  *
  78.  */
  79.  
  80. MRESULT EXPENTRY MainDlgProc(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  81. {
  82.    HPOINTER hpointer;
  83.    USHORT   usRet;
  84.  
  85.    switch(msg)
  86.    {
  87.       case WM_INITDLG:
  88.          hpointer = WinLoadPointer(HWND_DESKTOP,            /* Set Nead Icon */
  89.                                    (HMODULE) NULL,IDR_XRD);
  90.          WinPostMsg(hwnd,WM_SETICON,hpointer,0L);
  91.                                                        
  92.                                                               
  93.          /* Get XRs from file on Command line, or prompt for file name */
  94.          WinPostMsg(hwnd,WM_USER,NULL,NULL);
  95.          return 0L;
  96.  
  97.       case WM_USER:  /* Posted by WM_INITDLG allows main window to open 1st */
  98.          OpenFile(hwnd, COMMAND_LINE_FILE ? ARGFILE : NULL);
  99.          return 0L;
  100.  
  101.       case WM_COMMAND:
  102.          switch(COMMANDMSG(&msg)->cmd)
  103.          {
  104.             case IDD_NEWFILE:     /* Select another file to view/edit XRs */
  105.                OpenFile(hwnd,0);
  106.                return 0L;
  107.  
  108.             case IDD_ADD:         /* Add an XR to current list in memory  */
  109.                AddXR(hwnd);
  110.                return 0L;
  111.  
  112.             case IDD_DELETE:      /* Delete an XR from memory             */
  113.                DeleteCurXR(hwnd);
  114.                return 0L;
  115.  
  116.             case IDD_WRITE:       /* Write XR's out to disk               */
  117.                WriteXRs(hwnd);
  118.                return 0L;
  119.  
  120.             case IDD_EDIT:        /* Edit the hilited XR                  */
  121.                EditXR(hwnd);
  122.                return 0L;
  123.          
  124.             case IDD_ASM:
  125.                   LinkAsm();
  126.                   return 0;
  127.  
  128.             case IDD_COPY:        /* Copy and Paste aren't                */
  129.             case IDD_PASTE:       /* currently implemented                */
  130.                return 0L;
  131.  
  132.             case IDD_QUIT:
  133.                if(FILE_CHANGED)   /* Give user a chance to save changes   */
  134.                {
  135.                   usRet=WinMessageBox(HWND_DESKTOP,hwnd,
  136.                   "The current file has been changed.  Do you"
  137.                   "wish to save the changes before proceeding?",
  138.                   "Warning",NULL,MB_YESNOCANCEL | MB_ICONQUESTION);
  139.                   switch(usRet)
  140.                   {
  141.                      case MBID_YES:    /* They want to save the XRs       */
  142.                         WriteXRs(hwnd);
  143.                         break;
  144.                      case MBID_CANCEL: /* They don't really want to quit  */
  145.                         return 0L;
  146.                   }
  147.                }
  148.                WinDismissDlg(hwnd,TRUE);
  149.                return 0L;
  150.          }
  151.  
  152.       case WM_CONTROL:
  153.          switch(SHORT1FROMMP(mp1))
  154.          {
  155.             case IDD_LBOX:
  156.                switch(SHORT2FROMMP(mp1))
  157.                {
  158.                   case LN_SELECT:       /* A new item has been hi-lited */
  159.                      ShowXRType(hwnd);  /* Display appropriate XR Type  */
  160.                      return 0L;
  161.  
  162.                   case LN_ENTER:        /* Edit the selected XR         */
  163.                      EditXR(hwnd);
  164.                      return 0L;
  165.                }
  166.          }
  167.    }
  168.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  169. }
  170.  
  171.  
  172. /*
  173.  * Function name: AddXRProc()
  174.  *
  175.  */
  176.  
  177. MRESULT EXPENTRY AddXRProc(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  178. {
  179.    static CHAR bPDat = 0; /* flag indicating if the pPDat struct is valid */
  180.    PASSDATA FAR *pPDat;   /* struct used to pass in default XR name       */
  181.  
  182.    switch(msg)
  183.    {
  184.       case WM_INITDLG:
  185.          bPDat = 0;
  186.          WinSendDlgItemMsg(hwnd, IDD_XRNAME,EM_SETTEXTLIMIT,
  187.                                  MPFROM2SHORT(MAXXRNAME,0),NULL);
  188.          WinSendDlgItemMsg(hwnd, XR_LPASCII,BM_CLICK,0L,0L);
  189.  
  190.          pPDat=PVOIDFROMMP(mp2);
  191.          if(pPDat)
  192.          {
  193.             bPDat = 1;
  194.             WinSetDlgItemText(hwnd, IDD_XRNAME,pPDat->Point);
  195.             WinSetDlgItemText(hwnd, IDD_TITLE,
  196.                               "Add a Multi-type field to the XR");
  197.             WinEnableWindow(WinWindowFromID(hwnd,IDD_XRNAME),
  198.                             FALSE);                /* Disable XR Name field */
  199.             WinSetFocus(HWND_DESKTOP,WinWindowFromID(hwnd,DID_OK));
  200.  
  201.             return TRUE;       /* We don't want default focus setting */
  202.          }
  203.          return 0L;
  204.  
  205.       case WM_COMMAND:
  206.          switch(COMMANDMSG(&msg)->cmd)
  207.          {
  208.             case DID_OK:
  209.                if(bPDat == 0)          /* It is a new XR (not multi-type)   */
  210.                {
  211.                   WinQueryDlgItemText(hwnd, IDD_XRNAME, MAXXRNAME+1, szXRName);
  212.  
  213.                   if(!strlen(szXRName))    /* Don't allow a Null XR Name    */
  214.                   {
  215.                      WinAlarm(HWND_DESKTOP,WA_ERROR);
  216.                      WinMessageBox(HWND_DESKTOP, hwnd,
  217.                                    "Cannot create a NULL XR name.",
  218.                                    NULL, 0, MB_OK);
  219.                      return 0L;
  220.                   }
  221.  
  222.                   if(XRExists(szXRName))   /* Don't allow duplicate XR Name */
  223.                   {
  224.                      WinAlarm(HWND_DESKTOP,WA_ERROR);
  225.                      WinMessageBox(HWND_DESKTOP, hwnd,
  226.                           "XR name already exists.  Can't create that name.",
  227.                           NULL, 0, MB_OK);
  228.                      return 0L;
  229.                   }
  230.                }
  231.                usRetXRType = (USHORT) WinSendDlgItemMsg(hwnd, XR_ASCIIZ,
  232.                                                    BM_QUERYCHECKINDEX, 0L, 0L);
  233.                WinDismissDlg(hwnd, TRUE);
  234.                return 0L;
  235.  
  236.             case DID_CANCEL:
  237.                WinDismissDlg(hwnd, FALSE);
  238.                return 0L;
  239.          }
  240.          break;
  241.    }
  242.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  243. }
  244.  
  245.  
  246. /*
  247.  * Function name: AddXRProc()
  248.  *
  249.  
  250.  */
  251.  
  252.  
  253. MRESULT EXPENTRY AsciiEditProc(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  254. {
  255.    static PASSDATA FAR *pPDat;
  256.  
  257.    switch(msg)
  258.    {
  259.       case WM_INITDLG:
  260.          WinSendDlgItemMsg(hwnd, IDD_XRNAME,EM_SETTEXTLIMIT,
  261.                                  MPFROM2SHORT(MAXXRNAME,0),NULL);
  262.          WinSendDlgItemMsg(hwnd, IDD_XRVALUE,EM_SETTEXTLIMIT,
  263.                                  MPFROM2SHORT(MAXXRVALUE,0),NULL);
  264.          pPDat=PVOIDFROMMP(mp2);
  265.  
  266.          WinSetDlgItemText(hwnd, IDD_XRNAME,pPDat->Point);
  267.          WinSetDlgItemText(hwnd, IDD_XRTYPE,ConvTable[usRetXRType].szFormat);
  268.          WinSendDlgItemMsg(hwnd, IDD_NEEDBIT, BM_SETCHECK,
  269.                            MPFROM2SHORT(pPDat->fFlag,0),NULL);
  270.  
  271.          if(szAscii)   /* Set default XR Value if global var is != NULL */
  272.             WinSetDlgItemText(hwnd, IDD_XRVALUE,szAscii);
  273.  
  274.          if(pPDat->usIndex) /* Disable XRNAME if passed in a non-zero value */
  275.          {
  276.             WinEnableWindow(WinWindowFromID(hwnd,IDD_XRNAME),FALSE);
  277.             WinEnableWindow(WinWindowFromID(hwnd,IDD_NEEDBIT),FALSE);
  278.             WinSetFocus(HWND_DESKTOP,WinWindowFromID(hwnd,IDD_XRVALUE));
  279.             return TRUE;       /* We don't want default focus setting */
  280.          }
  281.          return 0L;
  282.  
  283.       case WM_COMMAND:
  284.          switch(COMMANDMSG(&msg)->cmd)
  285.          {
  286.             case DID_OK:
  287.                pPDat->fFlag = (BYTE) WinSendDlgItemMsg(hwnd, IDD_NEEDBIT,
  288.                                                        BM_QUERYCHECK,
  289.                                                        0L, 0L);
  290.                WinQueryDlgItemText(hwnd, IDD_XRNAME, MAXXRNAME+1, szXRName);
  291.  
  292.                if(!strlen(szXRName))    /* They nulled out the name */
  293.                {
  294.                   WinAlarm(HWND_DESKTOP,WA_ERROR);
  295.                   WinMessageBox(HWND_DESKTOP, hwnd,
  296.                                 "Cannot create a NULL XR name.",
  297.                                 NULL, 0, MB_OK);
  298.                   return 0L;
  299.                }
  300.  
  301.                GetMem(szScratch,MAXXRVALUE+1);  /* Allocate buffer for value */
  302.                WinQueryDlgItemText(hwnd, IDD_XRVALUE, MAXXRVALUE+1, szScratch);
  303.  
  304.                if(!strlen(szScratch))    /* They nulled out the value */
  305.                {
  306.                   FreeMem(szScratch,MAXXRVALUE+1); /* Free the value buffer */
  307.                   WinAlarm(HWND_DESKTOP,WA_ERROR);
  308.                   WinMessageBox(HWND_DESKTOP, hwnd,
  309.                                 "An XR can't have a NULL value.",
  310.                                 NULL, 0, MB_OK);
  311.                   return 0L;
  312.                }
  313.  
  314.                if(stricmp(szXRName,pPDat->Point)) /* changed the XR name */
  315.                {
  316.                   if(XRExists(szXRName))  /* Can't have duplicate XR names */
  317.                   {
  318.                      WinAlarm(HWND_DESKTOP,WA_ERROR);
  319.                      WinMessageBox(HWND_DESKTOP, hwnd,
  320.                             "XR name already exists.  Can't create that name.",
  321.                             NULL, 0, MB_OK);
  322.  
  323.                      FreeMem(szScratch,MAXXRVALUE+1);  /* Free value buffer */
  324.                      return 0L;
  325.                   }
  326.                }
  327.  
  328.                ResizeMem(szScratch,MAXXRVALUE+1,/* Resize buf to actual size */
  329.                          strlen(szScratch)+1);
  330.  
  331.                WinDismissDlg(hwnd, TRUE);
  332.                return 0L;
  333.  
  334.             case DID_CANCEL:
  335.                WinDismissDlg(hwnd, FALSE);
  336.                return 0L;
  337.          }
  338.          break;
  339.    }
  340.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  341. }
  342.  
  343.  
  344. /*
  345.  * Function name: IconDlgProc()
  346.  *
  347.  */
  348.  
  349. MRESULT EXPENTRY IconDlgProc(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  350. {
  351.    switch(msg)
  352.    {
  353.       case WM_INITDLG:
  354.          return 0L;
  355.  
  356.       case WM_COMMAND:
  357.          switch(COMMANDMSG(&msg)->cmd)
  358.          {
  359.             case DID_OK:
  360.                WinDismissDlg(hwnd, TRUE);
  361.                return 0L;
  362.          }
  363.    }
  364.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  365. }
  366.  
  367.  
  368. /*
  369.  * Function name: MultiTypeProc()
  370.  *
  371.  */
  372.  
  373. MRESULT EXPENTRY MultiTypeProc(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  374. {
  375.    static HOLDFXR *pFXR;        /* Points to the current XR         */
  376.    static PASSDATA FAR *pPDat;  /* Points to the passed Data struct */
  377.    static REENTER *CurEntry;    /* Points to most recent data frame */
  378.    REENTER *ReEntHold;          /* Temp used to setup the frame     */
  379.    PASSDATA PDat;               /* Used for call to EditXRValue     */
  380.    USHORT *pusPtr,cnt;          /* Utility vars                     */
  381.    SHORT  sOffset;
  382.    CHAR   *pInsert,*pValue,*pDelete;
  383.    CHAR   szCodePage[LENUSHORTBUF];
  384.    BYTE   fNeed;                /* Holds state of need checkbox     */
  385.  
  386.    switch(msg)
  387.    {
  388.       case WM_INITDLG:
  389.          pPDat = PVOIDFROMMP(mp2);             /* Set up static vars        */
  390.          pFXR  = (HOLDFXR *) pPDat->Point;
  391.  
  392.          GetMem(ReEntHold,sizeof(REENTER));    /* Allows for recusive calls */
  393.          ReEntHold->pPDat = pPDat;
  394.          ReEntHold->pFXR  = pFXR;
  395.          ReEntHold->next  = CurEntry;
  396.          CurEntry = ReEntHold;
  397.  
  398.          WinSendDlgItemMsg(hwnd, IDD_NEEDBIT, BM_SETCHECK, /* Need bit setup */
  399.                            MPFROM2SHORT((pFXR->fXR&0x80)? TRUE : FALSE,0),
  400.                            NULL);
  401.  
  402.          WinSetDlgItemText(hwnd,IDD_XRTYPE,"");  /* Setup the codepage */
  403.          WinSetDlgItemText(hwnd,IDD_XRNAME,pFXR->szName);
  404.          WinSendDlgItemMsg(hwnd, IDD_CODEPAGE,EM_SETTEXTLIMIT,
  405.                                  MPFROM2SHORT(LENUSHORTBUF-1,0),NULL);
  406.  
  407.          pusPtr= (USHORT *) ((CHAR *) pFXR->aValue+pPDat->usMultiOffset);
  408.          pusPtr++;       /* Skip the XR_Type field and point to codepage */
  409.          sprintf(szCodePage,"%u",*pusPtr);
  410.          WinSetDlgItemText(hwnd, IDD_CODEPAGE,szCodePage);
  411.  
  412.          pusPtr++;      /* Skip codepage and point to the field count */
  413.  
  414.          for(cnt=0;cnt< *pusPtr;cnt++) /* Add each field to the L-Box */
  415.          {
  416.             pInsert = MultiTypeIndex(pFXR->aValue+pPDat->usMultiOffset,cnt);
  417.             pValue = XRValueString(hwnd,pInsert); /* Ptr to asciiz string */
  418.  
  419.             WinSendDlgItemMsg(hwnd, IDD_LBOX, LM_INSERTITEM,
  420.                               MPFROM2SHORT(LIT_END,0),
  421.                               MPFROMP(pValue));
  422.             FreeMem(pValue,strlen(pValue)+1);  /* Free asciiz string */
  423.          }
  424.          return 0L;
  425.  
  426.       case WM_CONTROL:
  427.          switch(SHORT1FROMMP(mp1))
  428.          {
  429.             case IDD_LBOX:
  430.                switch(SHORT2FROMMP(mp1))
  431.                {
  432.                   case LN_SELECT:   /* Display proper XR type for selection */
  433.                      sOffset = (SHORT) WinSendDlgItemMsg(hwnd, IDD_LBOX,
  434.                                                        LM_QUERYSELECTION,0,0);
  435.                      if(sOffset<0)
  436.                         break;
  437.  
  438.                      pValue = MultiTypeIndex(pFXR->aValue+pPDat->usMultiOffset,
  439.                                              sOffset);
  440.                      pusPtr = (USHORT *) pValue;
  441.  
  442.                      WinSetDlgItemText(hwnd,IDD_XRTYPE,
  443.                                 ConvTable[LookupXRType(*pusPtr)].szFormat);
  444.                      break;
  445.  
  446.                   case LN_ENTER:  /* Setup and edit a m-m field */
  447.                      sOffset = (SHORT) WinSendDlgItemMsg(hwnd, IDD_LBOX,
  448.                                                        LM_QUERYSELECTION,0,0);
  449.                      if(sOffset<0)
  450.                         return 0L;
  451.  
  452.                      PDat.Point         = (CHAR *) pFXR; /* Pass curr data */
  453.                      PDat.cbMulti       = pPDat->cbMulti;
  454.                      PDat.usMultiOffset = pPDat->usMultiOffset;
  455.                      PDat.usIndex       = (USHORT) sOffset;
  456.  
  457.                      if(EditXRValue(hwnd,&PDat)) /* They didn't cancel */
  458.                      {
  459.                         pInsert=MultiTypeIndex(pFXR->aValue
  460.                                                 + pPDat->usMultiOffset,
  461.                                                sOffset);
  462.                         pValue =XRValueString(hwnd,pInsert);
  463.  
  464.                         WinSendDlgItemMsg(hwnd, IDD_LBOX, LM_SETITEMTEXT,
  465.                                           MPFROMSHORT(sOffset),
  466.                                           MPFROMP(pValue));
  467.                         FreeMem(pValue,strlen(pValue)+1); /* Free asciiz str */
  468.                      }
  469.                      return 0L;
  470.                }
  471.          }
  472.  
  473.       case WM_COMMAND:
  474.          switch(COMMANDMSG(&msg)->cmd)
  475.          {
  476.             case IDD_ADD:                  /* Add an item for a m-m */
  477.                MultiAdd(hwnd, pFXR,pPDat);
  478.                return 0L;
  479.  
  480.             case IDD_EDIT:  /* Setup and edit a m-m field */
  481.                sOffset = (SHORT) WinSendDlgItemMsg(hwnd, IDD_LBOX,
  482.                                                    LM_QUERYSELECTION,0,0);
  483.                if(sOffset<0)
  484.                   return 0L;
  485.  
  486.                PDat.Point         = (CHAR *) pFXR; /* Pass curr data */
  487.                PDat.cbMulti       = pPDat->cbMulti;
  488.                PDat.usMultiOffset = pPDat->usMultiOffset;
  489.                PDat.usIndex       = (USHORT) sOffset;
  490.  
  491.                if(EditXRValue(hwnd,&PDat)) /* They didn't cancel */
  492.                {
  493.                   pInsert=MultiTypeIndex(pFXR->aValue + pPDat->usMultiOffset,
  494.                                          sOffset);
  495.                   pValue =XRValueString(hwnd,pInsert);
  496.  
  497.                   WinSendDlgItemMsg(hwnd, IDD_LBOX, LM_SETITEMTEXT,
  498.                                     MPFROMSHORT(sOffset),
  499.                                     MPFROMP(pValue));
  500.                   FreeMem(pValue,strlen(pValue)+1); /* Free asciiz str */
  501.                }
  502.                return 0L;
  503.  
  504.             case IDD_DELETE:               /* Delete hi-lited item  */
  505.                sOffset = (USHORT) WinSendDlgItemMsg(hwnd, IDD_LBOX,
  506.                                                     LM_QUERYSELECTION,0,0);
  507.                if(sOffset<0)   /* No item is currently selected */
  508.                   return 0L;
  509.  
  510.                WinSendDlgItemMsg(hwnd, IDD_LBOX, LM_DELETEITEM,
  511.                                  MPFROMSHORT(sOffset),0L);
  512.  
  513.                /* Get pointers to start of selected field and the following
  514.                   field, then move the rest of the XR back, resize the
  515.                   buffer, and change the XR Value counter                  */
  516.  
  517.                pDelete = MultiTypeIndex(pFXR->aValue+pPDat->usMultiOffset,
  518.                                         sOffset);
  519.                pValue  = MultiTypeIndex(pFXR->aValue+pPDat->usMultiOffset,
  520.                                         sOffset+1);
  521.                memmove(pDelete,pValue,pFXR->cbValue-(pValue-pFXR->aValue));
  522.                ResizeMem(pFXR->aValue,pFXR->cbValue,
  523.                          pFXR->cbValue-(pValue-pDelete));
  524.                pFXR->cbValue -= pValue-pDelete;
  525.  
  526.                /* Decrement the field count in the m-m */
  527.                pusPtr  = (USHORT *) ((CHAR *) pFXR->aValue +
  528.                                               pPDat->usMultiOffset);
  529.                pusPtr+=2;         /* Point to the field count */
  530.                *pusPtr -= 1;      /* Decrement the field cnt  */
  531.  
  532.                FILE_CHANGED = TRUE;
  533.                return 0L;
  534.  
  535.             case DID_DONE:
  536.                /* Handle the possible change of the need checkbox */
  537.                fNeed = (BYTE) WinSendDlgItemMsg(hwnd, IDD_NEEDBIT,
  538.                                                 BM_QUERYCHECK,
  539.                                                 0L, 0L);
  540.                if(fNeed)
  541.                   fNeed = 0x80;
  542.                if(fNeed != (pFXR->fXR & 0x80)) /* Need changed */
  543.                {
  544.                   pFXR->fXR = (pFXR->fXR & 0x7F) | fNeed;
  545.                   FILE_CHANGED = TRUE;
  546.                }
  547.  
  548.                /* Handle the possible change of the codepage */
  549.                WinQueryDlgItemText(hwnd, IDD_CODEPAGE,
  550.                                    LENUSHORTBUF, szCodePage);
  551.                sscanf(szCodePage,"%u",&cnt);
  552.                pusPtr= (USHORT *) ((CHAR *) pFXR->aValue+pPDat->usMultiOffset);
  553.                pusPtr++;    /* Skip the XR_Type field and point to codepage */
  554.                if(*pusPtr != cnt) /* They changed the codepage value */
  555.                {
  556.                   *pusPtr = cnt;
  557.                   FILE_CHANGED = TRUE;
  558.                }
  559.  
  560.                ReEntHold = CurEntry->next;       /* Finish recursion safety */
  561.                FreeMem(CurEntry,sizeof(REENTER));
  562.                CurEntry = ReEntHold;
  563.                if(CurEntry)
  564.                {
  565.                   pPDat = CurEntry->pPDat;
  566.                   pFXR  = CurEntry->pFXR;
  567.                }
  568.                WinDismissDlg(hwnd, TRUE);
  569.                return 0L;
  570.          }
  571.    }
  572.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  573. }
  574.  
  575.  
  576. /*
  577.  * Function name: ShowXRType()
  578.  *
  579.  */
  580.  
  581. VOID ShowXRType(HWND hwnd)
  582. {
  583.    USHORT usXRType;         /* Holds the offset of XRType into ConvTable */
  584.    HOLDFXR *pFXR;
  585.  
  586.    pFXR = GetCurFXR(hwnd,pHoldFXR); /* Points to the selected XR */
  587.    if(!pFXR)                        /* Kill line if nothing is selected */
  588.    {
  589.       WinSetDlgItemText(hwnd,IDD_XRTYPE,"");
  590.       return;
  591.    }
  592.    usXRType = LookupXRType((USHORT) *pFXR->aValue);
  593.  
  594.    WinSetDlgItemText(hwnd,IDD_XRTYPE,ConvTable[usXRType].szFormat);
  595. }
  596.  
  597.  
  598.  
  599. /*
  600.  * Function name: EditXR()
  601.  *
  602.  */
  603.  
  604. BOOL EditXR(HWND hwnd)
  605. {
  606.    HOLDFXR *pFXR=pHoldFXR;  /* Pointer for selected XR */
  607.    LONG offset,lCnt;        /* Both used to reference offset of selected XR */
  608.    PASSDATA PData;
  609.  
  610.    if(!FILE_ISOPEN)
  611.       return(FALSE);
  612.  
  613.    offset = lCnt = (LONG) WinSendDlgItemMsg(hwnd, IDD_LBOX,
  614.                                             LM_QUERYSELECTION,0,0);
  615.  
  616.    if(offset<0)        /* Nothing was selected */
  617.       return(FALSE);
  618.  
  619.    while(lCnt--)         /* Get to the right XR */
  620.       pFXR = pFXR->next;
  621.  
  622.    PData.Point         = (CHAR *) pFXR;        /* Set the pass data struct */
  623.    PData.usMultiOffset = 0;
  624.    PData.cbMulti       = 0;
  625.  
  626.    if(EditXRValue(hwnd,&PData))  /* It worked */
  627.    {
  628.       WinSendDlgItemMsg(hwnd, IDD_LBOX,LM_SETITEMTEXT,
  629.                         MPFROMSHORT((SHORT) offset),MPFROMP(pFXR->szName));
  630.       return(TRUE);
  631.    }
  632.    return(FALSE);
  633. }
  634.  
  635.  
  636. /*
  637.  * Function name: GetCurFXR()
  638.  *
  639.  */
  640.  
  641. HOLDFXR *GetCurFXR(HWND hwnd, HOLDFXR *pFXR)
  642. {
  643.    LONG lOffset;
  644.  
  645.    lOffset = (LONG) WinSendDlgItemMsg(hwnd, IDD_LBOX,
  646.                                       LM_QUERYSELECTION,0,0);
  647.  
  648.    if(lOffset<0)      /* Nothing is highlighted */
  649.       return(NULL);
  650.  
  651.    while(lOffset--)
  652.    {
  653.       pFXR = pFXR->next;
  654.    }
  655.  
  656.    return(pFXR);
  657. }
  658. /************************************/
  659. /************************************/
  660. /************************************/
  661.