home *** CD-ROM | disk | FTP | other *** search
/ High Voltage Shareware / high1.zip / high1 / DIR4 / V12N15.ZIP / DEMODL.ZIP / DEMODLL.C < prev    next >
C/C++ Source or Header  |  1993-06-04  |  9KB  |  243 lines
  1. // DEMODLL.C - Demonstrate use of WINHELP internal functions
  2. // and access to "baggage" files within a Windows HLP file.
  3. // Copyright (C) 1993 Ray Duncan
  4. // PC Magazine * Ziff Davis Publishing
  5.  
  6. #include <windows.h>
  7. #include <commdlg.h>
  8. #include "dll.h"
  9. #include "demodll.h"
  10.  
  11. #define READSIZE 32768                      // size of I/O buffer
  12. #define EXENAMESIZE 256                     // max size of pathname
  13.  
  14. // far pointers to WINHELP internal functions
  15. LPFN_HFSOPENSZ      lpfnHfsOpenSz;             // open HLP file system 
  16. LPFN_RCCLOSEHFS     lpfnRcCloseHfs;            // close HLP file system
  17. LPFN_FACCESSHFS     lpfnFAccessHfs;            // check baggage file
  18. LPFN_HFOPENHFS      lpfnHfOpenHfs;             // open baggage file
  19. LPFN_LCBREADHF      lpfnLcbReadHf;             // read baggage file
  20. LPFN_RCCLOSEHF      lpfnRcCloseHf;             // close baggage file
  21.  
  22. //
  23. // LibMain() -- initialization routine called by system loader (via
  24. // LibEntry) when DLL is first loaded.  Called with the module handle
  25. // for the DLL, the size of the local heap, and a pointer to the
  26. // command line.  Returns TRUE if DLL initialization successful, 
  27. // FALSE if initialization failed.
  28. //
  29.  
  30. INT CALLBACK LibMain(HANDLE hModule, WORD wDataSeg, WORD cbHeap, LPSTR lpchCmdLine)
  31. {
  32.     if (cbHeap)                             // unlock data segment
  33.         UnlockData(0);                      // if DLL has its own
  34.                                             // local heap
  35.     return(TRUE); 
  36. }
  37.  
  38. // 
  39. // WEP - termination routine called by system just before the
  40. // DLL is unloaded from memory.  The parameter idParam is not used.
  41. // The routine always returns TRUE.
  42. //
  43. INT CALLBACK WEP(INT idParam)
  44. {
  45.     return(TRUE);
  46. }
  47.  
  48. // 
  49. // LDLLHandler() -- Callback entry point from WINHELP.EXE. Called
  50. // with DW_WHATMSG the first time a macro within the DLL is run from
  51. // the HLP file. The routine will be called additional times with
  52. // other messages depending on what flags were returned by this
  53. // routine in response to the DW_WHATMSG message.
  54. //
  55. LONG CALLBACK LDLLHandler(WORD wMsg, LONG lParam1, LONG lParam2)
  56. {
  57.     switch(wMsg)
  58.     {
  59.         case DW_WHATMSG:                    // we only want the
  60.             return(DC_CALLBACKS);            // DW_CALLBACKS message
  61.  
  62.         case DW_CALLBACKS:                  // save entry points
  63.             GetCallBacks((VPTR) lParam1);
  64.             return(TRUE);
  65.     }
  66.  
  67.     return(FALSE);
  68. }
  69.  
  70.  
  71. //
  72. // GetCallBacks -- called from LDLLHandler in response to the
  73. // DW_CALLBACKS message. Extracts the addresses of the WINHELP
  74. // entry points for the functions that will be used by 
  75. // CopyBaggage from the far pointer array whose address was 
  76. // passed to LDLLHandler, and saves the addresses in 
  77. // global variables.
  78. //
  79. VOID GetCallBacks(VPTR VPtr)
  80. {
  81.     lpfnHfsOpenSz      = (LPFN_HFSOPENSZ) VPtr[HE_HfsOpenSz];
  82.     lpfnRcCloseHfs     = (LPFN_RCCLOSEHFS) VPtr[HE_RcCloseHfs];
  83.     lpfnFAccessHfs     = (LPFN_FACCESSHFS) VPtr[HE_FAccessHfs];
  84.     lpfnHfOpenHfs      = (LPFN_HFOPENHFS) VPtr[HE_HfOpenHfs];
  85.     lpfnLcbReadHf      = (LPFN_LCBREADHF) VPtr[HE_LcbReadHf];
  86.     lpfnRcCloseHf      = (LPFN_RCCLOSEHF) VPtr[HE_RcCloseHf];
  87.  
  88.     return;
  89. }
  90.  
  91. // 
  92. // CopyBaggage() -- called as a "macro" from within a HLP file
  93. // to copy a baggage file from the HLP file's internal file system 
  94. // to an ordinary DOS file.  Arguments are the name of the HLP 
  95. // file, the name of the baggage file, the default name for the
  96. // DOS file, the address of the Help error structure, and two
  97. // flags that control display of the SaveAs and advisory dialogs.
  98. // Returns TRUE if the copy was successful, FALSE otherwise.
  99. //
  100. BOOL CALLBACK CopyBaggage(LPSTR szHelpFile, LPSTR szSourceFile, 
  101.   LPSTR szDefaultDest, QME lpHelpError, UINT fSaveAs, UINT fAlert)
  102. {
  103.     BOOL    fStatus;                        // operation status 
  104.     HANDLE  hHelpFile = 0;                  // HLP file handle
  105.     HANDLE  hSourceFile = 0;                // baggage file handle
  106.     HFILE   hDestFile = -1;                 // output file handle
  107.     UINT    ReadLen, WriteLen;              // bytes read, written
  108.     HGLOBAL hBuffer = 0;                    // I/O buffer handle
  109.     LPBYTE  lpBuffer;                       // I/O buffer pointer
  110.     OPENFILENAME ofn;                       // used by common dialog
  111.     OFSTRUCT ofs;                           // used by OpenFile
  112.     CHAR    szDestFile[EXENAMESIZE];        // destination filename
  113.     CHAR    szTemp[256];                    // scratch buffer
  114.  
  115.     // set default error result and error action
  116.     lpHelpError->wError == wMERR_NONE;
  117.     lpHelpError->fwFlags = fwMERR_ABORT;
  118.  
  119.     // retrieve default destination filename 
  120.     lstrcpy(szDestFile, szDefaultDest);
  121.  
  122.     // try and open HLP file, exit if unsuccessful
  123.     hHelpFile = (*lpfnHfsOpenSz)(szHelpFile, fFSOpenReadOnly);
  124.     if(!hHelpFile)
  125.         goto CopyError;
  126.  
  127.     // check if source file exists within HLP file system
  128.     fStatus = (*lpfnFAccessHfs)(hHelpFile, szSourceFile, NULL);
  129.     if(!fStatus)
  130.         goto CopyError;
  131.  
  132.     // try and open the source file for I/O
  133.     hSourceFile = (*lpfnHfOpenHfs)(hHelpFile, szSourceFile, fFSOpenReadOnly);
  134.     if(!hSourceFile)
  135.         goto CopyError;
  136.  
  137.     if(fSaveAs)                                // use Save-As dialog?
  138.     {
  139.         // initialize the data structure used by the common Save-As
  140.         // dialog, then prompt the user for the destination filename,
  141.         // using the filename passed as szDefaultDest as the default
  142.         ofn.lStructSize = sizeof(OPENFILENAME); // length of structure
  143.         ofn.hwndOwner = NULL;                // handle of owner window
  144.         ofn.lpstrFilter = NULL;             // address of filter list
  145.         ofn.lpstrCustomFilter = NULL;       // custom filter address
  146.         ofn.nFilterIndex = 1L;              // ignored for now
  147.         ofn.lpstrFile = szDestFile;         // buffer for pathname
  148.         ofn.nMaxFile = EXENAMESIZE;         // size of buffer
  149.         ofn.lpstrFileTitle = NULL;          // buffer for filename only
  150.         ofn.lpstrInitialDir = NULL;         // initial directory 
  151.         ofn.lpstrTitle = NULL;              // title for dialog box
  152.         ofn.Flags = OFN_PATHMUSTEXIST |     // various dialog flags
  153.                     OFN_HIDEREADONLY | OFN_NOTESTFILECREATE;
  154.         ofn.lpstrDefExt = NULL;                // default extension
  155.  
  156.         if(!GetSaveFileName(&ofn))          // display save-as dialog
  157.             goto CopyError;                  // exit if user canceled
  158.     }
  159.  
  160.     // allocate memory for use as an I/O buffer
  161.     hBuffer = GlobalAlloc(GMEM_MOVEABLE, READSIZE);
  162.     if(!hBuffer)
  163.         goto CopyError;
  164.  
  165.     // get far pointer to the I/O buffer
  166.     lpBuffer = GlobalLock(hBuffer);
  167.  
  168.     // create the destination file
  169.     hDestFile = _lcreat(szDestFile, 0);
  170.     if(hDestFile == HFILE_ERROR)
  171.         goto CopyError;
  172.     
  173.     // copy the data from the HLP file system to the
  174.     // newly created destination file
  175.     do {
  176.  
  177.         ReadLen = (*lpfnLcbReadHf)(hSourceFile, lpBuffer, READSIZE);
  178.         WriteLen = _lwrite(hDestFile, lpBuffer, ReadLen);
  179.     
  180.         if(ReadLen != WriteLen)
  181.             goto CopyError;
  182.  
  183.      } while(ReadLen == READSIZE);
  184.  
  185.     // close all files, release I/O buffer
  186.     (*lpfnRcCloseHf)(hSourceFile);
  187.     (*lpfnRcCloseHfs)(hHelpFile);
  188.     _lclose(hDestFile);
  189.     GlobalUnlock(hBuffer);
  190.     GlobalFree(hBuffer);
  191.  
  192.     if(fAlert)                                // display alert?
  193.     {
  194.         // notify user of the successful file transfer
  195.         wsprintf(szTemp, "Baggage file %s\nfrom help file %s\n"
  196.                          "was copied to %s.",
  197.                  (LPSTR) szSourceFile, (LPSTR) szHelpFile,
  198.                  (LPSTR) szDestFile);
  199.         strlwr(szTemp);
  200.         MessageBox(NULL, szTemp, "DEMODLL", MB_OK);
  201.     }
  202.  
  203.     // return success flag to WINHELP.EXE
  204.     return(wMERR_NONE);
  205.  
  206. CopyError:                                  // common error exit
  207.  
  208.     // close any files that were opened, kill
  209.     // partial output file if necessary
  210.     if(hHelpFile)       
  211.         (*lpfnRcCloseHfs)(hHelpFile);
  212.     if(hSourceFile)     
  213.         (*lpfnRcCloseHf)(hSourceFile);
  214.     if(hDestFile != -1)
  215.     {
  216.         _lclose(hDestFile);
  217.         OpenFile(szDestFile, &ofs, OF_DELETE);
  218.     }
  219.  
  220.     // release I/O buffer if it was allocated
  221.     if(hBuffer)
  222.     {
  223.         GlobalUnlock(hBuffer);
  224.         GlobalFree(hBuffer);
  225.     }
  226.                                             // display alert?
  227.     if(fAlert)
  228.     {
  229.         // notify user of the unsuccessful operation
  230.         wsprintf(szTemp, "Baggage file %s\nfrom help file %s\n"
  231.                          "could not be copied.",
  232.                  (LPSTR) szSourceFile, (LPSTR) szHelpFile);
  233.         strlwr(szTemp);
  234.         MessageBox(NULL, szTemp, "DEMODLL", MB_OK);
  235.     }
  236.  
  237.     // set error code, return error flag to WINHELP.EXE
  238.     lpHelpError->wError = wMERR_ERROR;
  239.     return(wMERR_ERROR);
  240. }
  241.  
  242.  
  243.