home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: Graphics / Graphics.zip / xfitsvew.zip / XFITSview / textfile.c < prev    next >
C/C++ Source or Header  |  1998-04-05  |  19KB  |  529 lines
  1. /* TextFile routines for XFITSview */
  2. /*-----------------------------------------------------------------------
  3. *  Copyright (C) 1996
  4. *  Associated Universities, Inc. Washington DC, USA.
  5. *  This program is free software; you can redistribute it and/or
  6. *  modify it under the terms of the GNU General Public License as
  7. *  published by the Free Software Foundation; either version 2 of
  8. *  the License, or (at your option) any later version.
  9. *
  10. *  This program is distributed in the hope that it will be useful,
  11. *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. *  GNU General Public License for more details.
  14. *-----------------------------------------------------------------------*/
  15. #include <Xm/Xm.h> 
  16. #include <Xm/FileSB.h> 
  17. #include <stdlib.h>
  18. #include <stdio.h>
  19. #include <string.h>
  20. #include "fitsio.h"
  21. #include "zsubs.h"
  22. #include "gzipread.h"
  23. #include "textfile.h" 
  24. #include "messagebox.h" 
  25. #include "helpbox.h" 
  26. #include "xfitsview.h" /* a bit of uglyness for saving directories */
  27.  
  28. /* define file types */
  29. #define TEXTTYPE    1   /* Unix text file (LF only) */
  30. #define FITSTYPE    2   /* FITS file header */
  31. #define DOSTEXTTYPE 3   /* DOS text file (CR, LF) */
  32.   
  33. /* internal functions */
  34. /* Flush output buffer - TFilePtr already locked*/
  35. int TextFileFlush(TextFilePtr TFilePtr); /* returns 1 if OK */
  36. /* read text file buffer */
  37. int TextFileBufferIn(TextFilePtr TFilePtr);/* returns 1 if OK */
  38. /* If file specified then fills in file info in TextFileInfo structure */
  39. void TextFileOKCB (Widget filebox, XtPointer clientData, XtPointer callData);
  40. /* TextFile selection canceled */
  41. void TextFileCancelCB (Widget filebox, XtPointer clientData, XtPointer callData);
  42.  
  43.   
  44. /* create/initialize TextFileInfo structure                               */
  45. /* w is a Widget for dialog boxes to be attached to                       */
  46. /* if non null filename and directory filled in                           */
  47. TextFilePtr TextFileMake (Widget w, char* filename, char* directory)
  48. {
  49.   TextFilePtr TFilePtr;
  50.  
  51. /* create structure */
  52.   TFilePtr = (TextFilePtr)malloc(sizeof(TextFileInfo));
  53.   if (!TFilePtr) return TFilePtr; /* alloc failed? */
  54.  
  55. /* fill in value passed */
  56.   TFilePtr->w = w;
  57.   if (filename) { /* make copy */
  58.     TFilePtr->FileName = (char*)malloc(strlen(filename)+1);
  59.     strcpy (TFilePtr->FileName, filename);}
  60.   else
  61.     TFilePtr->FileName = NULL;
  62.   if (directory) { /* make copy */
  63.     TFilePtr->directory = (char*)malloc(strlen(directory)+1);
  64.     strcpy (TFilePtr->directory, directory);}
  65.   else
  66.     TFilePtr->directory = NULL;
  67.  
  68. /* others */
  69.     TFilePtr->file = NULL;
  70.     TFilePtr->OKfunc = NULL;
  71.     TFilePtr->CancelFunc = NULL;
  72.     TFilePtr->hFile = 0;
  73.     TFilePtr->Good = 0;
  74.     TFilePtr->HitEOF = 0;
  75.     TFilePtr->InBuffer = 0;
  76.     TFilePtr->BufferPos = 0;
  77.     TFilePtr->State = 0;
  78.     TFilePtr->FileType = 0;
  79.     TFilePtr->isGzip = 0;
  80.     TFilePtr->chkGzip = 1;
  81.  
  82.   return TFilePtr;
  83. } /* end TextFileMake */
  84.  
  85. /* delete TextFileInfo structure             */
  86. void TextFileKill (TextFilePtr TFilePtr)
  87. {
  88.   if (!TFilePtr) return; /* anybody home */
  89.  
  90. /* delete any characters string and buffer */
  91.   if (TFilePtr->FileName) free(TFilePtr->FileName);
  92.   if (TFilePtr->directory) free(TFilePtr->directory);
  93.  
  94. /* need to close output file? */
  95.   if (TFilePtr->file) fclose(TFilePtr->file);
  96.   if (TFilePtr->hFile) FileClose(TFilePtr->hFile);
  97.  
  98. /* delete any gzip structures */
  99.   if (TFilePtr->isGzip) gz_close();
  100.  
  101. /* delete structure */
  102.   free(TFilePtr);
  103. } /* end TextFileKill */
  104.  
  105. /* get file specification                                                 */
  106. /* inout = 1 => input; 2=> output                                         */
  107. /* TFilePtr->Good indicated if file selected                              */
  108. void TextFileFind (int inout, TextFilePtr TFilePtr, TextFileProc OKfunc,
  109.            TextFileProc CancelFunc)
  110. {
  111.   Widget       filebox;
  112.   XmString     wierdstring = NULL;
  113.   Arg          wargs[5]; 
  114.  
  115. /* save function pointesr */
  116.   TFilePtr->OKfunc = OKfunc;
  117.   TFilePtr->CancelFunc = CancelFunc;
  118.   TFilePtr->State = inout; /* input or output? */
  119.  
  120. /* bring up selection box */
  121.   filebox = (Widget) XmCreateFileSelectionDialog (TFilePtr->w, 
  122.                           "text_file", NULL, 0);
  123.   XtAddCallback (filebox, XmNokCallback, TextFileOKCB, (XtPointer)TFilePtr);
  124.   XtAddCallback (filebox, XmNcancelCallback, TextFileCancelCB, 
  125.          (XtPointer)TFilePtr);
  126.   XtAddCallback (filebox, XmNhelpCallback, HelpBoxTopicCB, 
  127.            (XtPointer)"Browser");
  128.  
  129. /* set directory if it is defined */
  130.   if (TFilePtr->directory) {
  131.     wierdstring = XmStringCreateSimple (TFilePtr->directory);
  132.     XtSetArg (wargs[0], XmNdirectory, wierdstring);
  133.     XtSetValues (filebox, wargs, 1);
  134.     if (wierdstring) XmStringFree(wierdstring); wierdstring = NULL;
  135.   }
  136.  
  137. /* Shazam appear: */
  138.   XtManageChild (filebox);
  139.   XtPopup (XtParent (filebox), XtGrabNone);
  140. /* all the action is in the callback routine */
  141. } /* end TextFileFind */
  142.   
  143. /* open text file                                                         */ 
  144. /* inout = 1 => input; 2=> output                                         */
  145. /* returns 1 if successful                                                */
  146. int TextFileOpen (TextFilePtr TFilePtr, int inout)
  147. { 
  148. /* use standard c I/O on write and fitsio on read which allows using the
  149.    gzip decompression routines */
  150.   char fullname[120];
  151.   int  length;
  152.   FITSfile *Fname;
  153.  
  154.   TFilePtr->State = inout;
  155.   
  156. /* put together full file name */
  157.   strcpy(fullname, TFilePtr->directory);
  158.   length = strlen(TFilePtr->directory);
  159.   if (length>0) fullname[length] = '/';
  160.   else length = -1;
  161.   strcpy(&fullname[length+1], TFilePtr->FileName);
  162.  
  163.   /* open for read */
  164.   if (inout==1) { 
  165.    Fname = (FITSfile*)MakeString(fullname);
  166.    TFilePtr->hFile = FileOpen(Fname);
  167.    KillString(Fname); /* as ye create shall thou destroy */
  168.    if (!TFilePtr->hFile) { /* open failed */
  169.      MessageShow ("Error openinging text file");
  170.      return 0; } /* end of open failed */
  171.    /* read first block, decide type */
  172.    if (!TextFileBufferIn(TFilePtr)) { /* I/O failed */
  173.      MessageShow ("Error reading text file");
  174.      TextFileClose(TFilePtr);
  175.      return 0; } /* end of I/O failed */
  176.   } /* end open for read */
  177.   /* open for write */
  178.   else if (inout==2) { 
  179.     TFilePtr->file = fopen ((const char*)fullname,"at");
  180.     if (!TFilePtr->file) { /* failed? */
  181.      MessageShow ("Error openinging text file");
  182.      return 0; } /* end of open failed */
  183.   } /* end open for write */
  184.   return 1; /* OK */
  185. } /* end TextFileOpen */
  186.   
  187. /* close file specified by handle TFilePtr                                */ 
  188. /* returns 1 if successful                                                */ 
  189. int TextFileClose(TextFilePtr TFilePtr)
  190. {
  191.   int good = 1;
  192.   if (!TFilePtr) return 0;   /* validity check */
  193.  
  194. /* flush buffer on write */
  195.   if ((TFilePtr->State==2) && (TFilePtr->BufferPos>0))
  196.     if (!TextFileFlush(TFilePtr))
  197.       {MessageShow("Error flushing text file buffer"); good = 0;}
  198. /* Close */
  199.   if (TFilePtr->State==1) {/* close read */
  200.     if (FileClose(TFilePtr->hFile)!=1) { /* close failed */
  201.       MessageShow("Error closing text file"); good = 0;}
  202.     TFilePtr->hFile = 0;
  203.     /* delete any gzip structures */
  204.     if (!TFilePtr->isGzip) gz_close();
  205.     TFilePtr->isGzip = 0;
  206.   } /* end close read */
  207.   else if (TFilePtr->State==2) {/* close write */
  208.     if (fclose(TFilePtr->file))
  209.       {MessageShow("Error closing text file"); good = 0;}
  210.     TFilePtr->file = NULL;
  211.   } /* end close write */
  212.  
  213.  
  214.  TFilePtr->State = 0; /* mark as closed */
  215.  
  216.   return good;
  217. } /* end TextFileClose */
  218.   
  219. /* Read a line of text from a file                                        */ 
  220. /* returns 1 if OK, 0 if failed, -1 -> HitEOF                             */ 
  221. /* maxchar is the maximum number of characters allowed in line */
  222. int TextFileRead(TextFilePtr TFilePtr, char* line, int maxchar)
  223. {
  224.    char *next, CR=13, LF=10, *linein;
  225.    long loop, count=0;
  226.  
  227.    if (!TFilePtr) return 0;   /* validity check */
  228.    if (!TFilePtr->State) return 0; /* active? */
  229.    linein = line;
  230.  
  231. /* branch by file type */
  232.    switch (TFilePtr->FileType) {
  233.       case TEXTTYPE: /* Unix text file */
  234. /* loop through buffer until hitting a LF */
  235.            next = (char *)(TFilePtr->Buffer + TFilePtr->BufferPos);
  236.            for (loop=0; loop<1000; loop++) {
  237.              if (TFilePtr->BufferPos>=TFilePtr->InBuffer) 
  238.            { /* read next buffer full */
  239.                 if (!TextFileBufferIn(TFilePtr)) { /* I/O failed */
  240.                     MessageShow ("Error reading text file");
  241.                      TextFileClose(TFilePtr);
  242.                      return 0;
  243.                      } /* end of I/O failed */
  244.                   next = (char *)(TFilePtr->Buffer);
  245.                   } /*end of read buffer */
  246.                if (TFilePtr->InBuffer<1) break; /* end of file? */
  247.                if (*next!=LF) 
  248.                   {count++; if (count<=maxchar) *line++ = *next; 
  249.            next++; 
  250.            TFilePtr->BufferPos++;}
  251.                else {TFilePtr->BufferPos++; break;}
  252.                } /* end of loop reading card */
  253.             *line = 0; /* terminating null */
  254.       /* done with file ?*/
  255.            if ((TFilePtr->InBuffer==0) && TFilePtr->HitEOF) {return -1;}
  256.            break;
  257.       case FITSTYPE: /* FITS file */
  258.            /* done? */
  259.            if ((TFilePtr->InBuffer==0) && TFilePtr->HitEOF) {return -1;}
  260.            /* Next 80 characters */
  261.            next = (char *)(TFilePtr->Buffer + TFilePtr->BufferPos);
  262.            for (loop=0; loop<80; loop++) {
  263.              if (TFilePtr->BufferPos>=TFilePtr->InBuffer) { /* read next buffer full */
  264.                 if (!TextFileBufferIn(TFilePtr)) { /* I/O failed */
  265.                     MessageShow ("Error reading text file");
  266.                      TextFileClose(TFilePtr);
  267.                      return 0;
  268.                      } /* end of I/O failed */
  269.                   next = (char *)(TFilePtr->Buffer);
  270.                   } /*end of read buffer */
  271.                if (TFilePtr->InBuffer<1) break; /* end of file? */
  272.                count++; 
  273.                if (count<=maxchar) *line++ = *next; 
  274.                next++; 
  275.                TFilePtr->BufferPos++;
  276.                } /* end of loop reading card */
  277.             *line = 0; /* terminating null */
  278.       /* done with file ? - check for "END     " card*/
  279.            if (!strncmp (linein, "END     ", 8)) 
  280.          {TFilePtr->InBuffer=0; TFilePtr->HitEOF = 1; return -1;}
  281.            break;
  282.       case DOSTEXTTYPE: /* line feeds in text file */
  283. /* loop through buffer until hitting a CR, drop LF */
  284.            next = (char *)(TFilePtr->Buffer + TFilePtr->BufferPos);
  285.            for (loop=0; loop<1000; loop++) {
  286.              if (TFilePtr->BufferPos>=TFilePtr->InBuffer) { /* read next buffer full */
  287.                 if (!TextFileBufferIn(TFilePtr)) { /* I/O failed */
  288.                     MessageShow ("Error reading text file");
  289.                      TextFileClose(TFilePtr);
  290.                      return 0;
  291.                      } /* end of I/O failed */
  292.                   next = (char *)(TFilePtr->Buffer);
  293.                   } /*end of read buffer */
  294.                if (TFilePtr->InBuffer<1) break; /* end of file? */
  295.                /*debug if (*next==LF) next++;  ignore line feeds */
  296.                if (*next!=LF) 
  297.                   {count++; if (count<=maxchar) *line++ = *next; 
  298.            next++; 
  299.            TFilePtr->BufferPos++;}
  300.                else {TFilePtr->BufferPos++; break;}
  301.                } /* end of loop reading card */
  302.             *line = 0; /* terminating null */
  303.       /* done with file ?*/
  304.            if ((TFilePtr->InBuffer==0) && TFilePtr->HitEOF) {return -1;}
  305.            break;
  306.       default: 
  307.            if ((TFilePtr->InBuffer==0) && TFilePtr->HitEOF) {return -1;}
  308.            sprintf (line, "Unknown file type ");
  309.            TFilePtr->InBuffer=0; 
  310.            TFilePtr->HitEOF = 1;
  311.            break;
  312.       }  /* end of branch by file type */
  313.    return 1;
  314. } /* end TextFileRead */
  315.   
  316. /* Write a line of text to a file                                          */ 
  317. /* returns 1 if OK, 0 if failed                                           */ 
  318. int TextFileWrite(TextFilePtr TFilePtr, char* line)
  319. {
  320.    long loop, count;
  321.    char *next, LF=10;
  322.  
  323.    if (!TFilePtr) return 0;   /* validity check */
  324.    if (TFilePtr->State!=2) {return 0;} /* Open write? */
  325.    count = strlen (line);
  326.    /* copy string to buffer flushing buffer when full */
  327.     next = (char *)(TFilePtr->Buffer + TFilePtr->BufferPos);
  328.    for (loop = 0; loop<count; loop++) {
  329.       if ((TFilePtr->BufferPos)+1>=TEXTBUFFER_SIZE) { /* flush buffer? */
  330.          if (!TextFileFlush(TFilePtr)) { /* I/O failed */
  331.             MessageShow ("Error writing text file");
  332.             TextFileClose(TFilePtr);
  333.             return 0;
  334.             } /* end of I/O failed */
  335.          next = (char *)(TFilePtr->Buffer);
  336.          } /* end flush buffer */
  337.  
  338.       *next++ = *line++; TFilePtr->BufferPos++;
  339.       } /* end loop copying string */
  340.    if ((TFilePtr->BufferPos)+1>=TEXTBUFFER_SIZE) { /* flush buffer? */
  341.       if (!TextFileFlush(TFilePtr)) { /* I/O failed */
  342.          MessageShow ("Error writing text file");
  343.          TextFileClose(TFilePtr);
  344.          return 0;
  345.          } /* end of I/O failed */
  346.       } /* end of flush buffer */
  347.    *next = LF; TFilePtr->BufferPos++;/* add LF */
  348.    return 1;
  349. } /* end TextFileWrite */
  350.  
  351. /* internal functions */
  352. /* Flush output buffer - TFilePtr already locked*/
  353. /* returns 1 if OK, 0 if failed */
  354. int TextFileFlush(TextFilePtr TFilePtr)
  355. {
  356.    long count;
  357.    size_t size, nout, number=1;
  358.    if (!TFilePtr) return 0;   /* validity check */
  359.    size = TFilePtr->BufferPos;
  360.    if (size<=0) return 1; /* nothing to do */
  361.    nout = fwrite ((const void*)TFilePtr->Buffer, size, number, 
  362.           TFilePtr->file);
  363.    if (nout!=1) return 0; /* write failed? */
  364.    TFilePtr->InBuffer = 0;
  365.    TFilePtr->BufferPos = 0;
  366.    return 1;
  367. } /* end TextFileFlush */
  368.  
  369. /* Read input buffer */
  370. /* returns 1 if OK, 0 if failed */
  371. int TextFileBufferIn(TextFilePtr TFilePtr)
  372. {
  373.    char CR=13, LF=10;
  374.    int hasSimple=0, hasCR=0, hasLF=0, hasBinary=0;
  375.    int count, i, nread, readret, error, nred;
  376.    unsigned char gzip_magic[2] = {"\037\213"}; /* gzip magic number */
  377.    cMemPtr test;
  378.  
  379.    if (!TFilePtr) return 0;   /* validity check */
  380.    if (TFilePtr->HitEOF) { /* previous EOF? */
  381.       TFilePtr->InBuffer = 0;
  382.       TFilePtr->BufferPos = 0;
  383.       return 1;}
  384.  
  385.    count = TEXTBUFFER_SIZE;
  386. /* regular or gzipped file? */
  387.   if (!TFilePtr->isGzip)
  388.     {nread = FileRead (TFilePtr->hFile, (MemPtr)TFilePtr->Buffer, count); 
  389.      error = nread==0; }
  390.   else
  391.     {nred = count;
  392.      readret = gz_read (&nred, (cMemPtr)TFilePtr->Buffer); /* read block */
  393.      nread = nred;
  394.      error = (readret != PR_SUCCESS) || (nread==0); }
  395.    
  396. /* look for magic number for gzip files on first read */
  397.   if ((!error) && TFilePtr->chkGzip) {
  398.     test = (cMemPtr)TFilePtr->Buffer;
  399.     TFilePtr->chkGzip = 0; /* only check first block */
  400.     if ((test[0]==gzip_magic[0]) && (test[1]==gzip_magic[1]))
  401.       { /* TFilePtr file is gzipped - set up */
  402.     TFilePtr->isGzip = 1; /* it's gzip compressed */
  403.     readret = FileSeek (TFilePtr->hFile, 0L);  /* reposition */
  404.     error = (readret != 1);
  405.     if (!error) readret = gz_init (TFilePtr->hFile);  /* init */
  406.     error = error || (readret != PR_SUCCESS);
  407.     if (!error) readret = gz_seek (0L); /* position */
  408.     error = error || (readret != PR_SUCCESS);
  409.     nred = count;
  410.     if (!error) readret = gz_read (&nred, (cMemPtr)TFilePtr->Buffer);
  411.     nread = nred;
  412.     error = error || (readret != PR_SUCCESS) || (nred==0);
  413.       }
  414.   } /* end of gzip check */
  415.  
  416. /*Error check */ 
  417.    if (nread<count) { /* hit EOF in read - some good data */
  418.       TFilePtr->HitEOF = 1; error = 0;}
  419.    if (error) return 0; /* read failed? */
  420.  
  421.    TFilePtr->InBuffer = nread;
  422.    TFilePtr->BufferPos = 0;
  423.  
  424.    /* determine file type if not known */
  425.    if (!TFilePtr->FileType) { /* determine file type from first buffer */
  426.      /* look for FITS intro */
  427.       hasSimple = (!strncmp ((char*)TFilePtr->Buffer, "SIMPLE  =      ", 15));
  428.       /* look for carrage return */
  429.       for (i=0;i<nread;i++) 
  430.     {if (TFilePtr->Buffer[i]==CR)
  431.        {hasCR = 1;  break;}}
  432.       /* look for line feed */
  433.       for (i=0;i<nread;i++) 
  434.     {if (TFilePtr->Buffer[i]==LF)
  435.        {hasLF = 1;  break;}}
  436.       /* look for binary values */
  437.       for (i=0;i<nread;i++) 
  438.     {if (TFilePtr->Buffer[i]>128)
  439.        {hasBinary = 1;  break;}}
  440.       /* decide type */
  441.       /* DOS has CR and LF */
  442.       if (hasCR && hasLF) TFilePtr->FileType = DOSTEXTTYPE;
  443.       /* Unix text has LF but no CR */
  444.       if ((!TFilePtr->FileType) && hasLF) TFilePtr->FileType = TEXTTYPE;
  445.       /* FITS has SIMPLE = ... but no CR or LF */
  446.       if ((!TFilePtr->FileType) && hasSimple) TFilePtr->FileType = FITSTYPE;
  447.       
  448.       /* check for bad file types */
  449.       if (hasBinary && (!hasSimple)) /* can't cope with binary files */
  450.     {MessageShow("Selected file appears to be neither text nor FITS");
  451.      return 0;}
  452.       if (!TFilePtr->FileType) /* Don't recognize text file type */
  453.     {MessageShow("Unrecognized text file type");
  454.      return 0;}
  455.       } /* end of determining file type */
  456.    return 1;
  457. } /* end TextFileBufferIn */
  458.   
  459. void TextFileOKCB (Widget filebox, XtPointer clientData, XtPointer callData)
  460. /* Gets file information and calls OKfunc if non NULL*/
  461. {
  462.   XmFileSelectionBoxCallbackStruct *cbs;
  463.   TextFilePtr TFilePtr = (TextFilePtr)clientData;
  464.   XPointer XPtr;
  465.   char *filename, *directory;
  466.   int i, length, first;
  467.  
  468.   cbs = (XmFileSelectionBoxCallbackStruct *) callData;
  469.  
  470. /* delete any old file names */
  471.   if (TFilePtr->FileName) free(TFilePtr->FileName);
  472.   if (TFilePtr->directory) free(TFilePtr->directory);
  473.  
  474. /* get file name */
  475.  if (!XmStringGetLtoR (cbs->value, XmSTRING_DEFAULT_CHARSET, &filename))
  476.    return; /* error */
  477. /* remove directory part of name */
  478.   length = strlen(filename);
  479.   first = 0;
  480.   for (i=0; i<length; i++) if (filename[i]=='/') first = i+1;
  481.   TFilePtr->FileName = (char*)malloc(length-first+2);
  482.   strcpy (TFilePtr->FileName,&filename[first]);
  483.  
  484. /* get directory name */
  485.   if (!XmStringGetLtoR (cbs->dir, XmSTRING_DEFAULT_CHARSET, &directory))
  486.     return; /* error */
  487.   TFilePtr->directory = directory;
  488.  
  489. /* ugly hack to save directory information */
  490.   if (TFilePtr->State==1)
  491.     {
  492.       if (!FITS_dir) FITS_dir = MakeString(" ");
  493.       StringFill(FITS_dir, directory); 
  494.     }
  495.   if (TFilePtr->State==2)
  496.     {
  497.       if (!log_dir) log_dir = MakeString(" ");
  498.       StringFill(log_dir, directory); 
  499.     }
  500.  
  501. /* Shazam disappear and die */
  502.   XtUnmanageChild (filebox); 
  503.   XtPopdown (XtParent (filebox)); 
  504.   XtDestroyWidget(filebox); 
  505.   XtFree(filename);
  506.  
  507. /* call func if specified */
  508.   XPtr = (XPointer)TFilePtr;
  509.   if (TFilePtr->OKfunc) TFilePtr->OKfunc(XPtr);
  510. } /* end FileOKCB */
  511.  
  512. void TextFileCancelCB (Widget filebox, XtPointer clientData, XtPointer callData)
  513. /* cancel file selection dialog box */
  514. /* deletes box and calls CancelFunc if non NULL*/
  515. {
  516.   TextFilePtr TFilePtr = (TextFilePtr)clientData;
  517.   XPointer XPtr;
  518.  
  519. /* Shazam disappear and die */
  520.   XtUnmanageChild (filebox); 
  521.   XtPopdown (XtParent (filebox)); 
  522.   XtDestroyWidget(filebox); 
  523.  
  524. /* call func if specified */
  525.   XPtr = (XPointer)TFilePtr;
  526.   if (TFilePtr->CancelFunc) TFilePtr->CancelFunc(XPtr);
  527. } /* end FileCancelCB */
  528.  
  529.