home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Toolbox / Visual Basic Toolbox (P.I.E.)(1996).ISO / dll_gen / vbdllcom / vbdllcom.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-16  |  7.0 KB  |  219 lines
  1. /*------------------------------------------------------------------------*
  2.     Andreas Weidinger (c) 1995
  3.     EDV-Beratung und Entwicklung
  4.     Glashⁿttenstra▀e 41
  5.     40627 Dⁿsseldorf 
  6.     Germany
  7.     Tel:        (0211) 273988
  8.     CompuServe:    100416,2775
  9.  
  10.     IT WOULD BE NICE IF ANYBODY HOW HAD SIMILAR PROBLEMES OR HAS FOUND
  11.     OUT A MORE EASIER WAY TO PASS ANY DATA FROM VB TO A DLL AND BACK
  12.     CONTACT ME:
  13.     
  14. *------------------------------------------------------------------------*/
  15. /*------------------------------------------------------------------------*/
  16. #define NOCOMM
  17. /*------------------------------------------------------------------------*/
  18.         /*StandardHeader*/
  19. #include<windows.h>
  20.  
  21.         /*ExternObjectHeader*/       
  22. /*------------------------------------------------------------------------*/
  23. /*      Include headerfile for VB-API-Library*/
  24. /*------------------------------------------------------------------------*/
  25. #include"vbapi.h"
  26.         /*ApplicationHeader*/
  27. #include"vbdllcom.h"
  28. /*------------------------------------------------------------------------*/
  29. /*------------------------------------------------------------------------*/
  30. /*      Function Prototypes */
  31. /*------------------------------------------------------------------------*/
  32. /*------------------------------------------------------------------------*/
  33. SHORT FAR PASCAL   LibMain
  34. (HANDLE hModule, WORD wDataSeg, WORD wHeapSize, LPSTR lpszCmdLine); 
  35. #ifdef __cplusplus
  36. extern "C" {
  37. #endif
  38. SHORT DLLAPI  WEP (SHORT nSystemExit);
  39. #ifdef __cplusplus
  40. }
  41. #endif
  42. /*------------------------------------------------------------------------*/
  43. /*------------------------------------------------------------------------*/
  44. /*      Global Variables
  45. /*------------------------------------------------------------------------*/
  46. /*------------------------------------------------------------------------*/
  47. static HANDLE hInstance;
  48. /*-------------------------------------------------------------------------*
  49. *
  50. *   Function:   DLL Library EntryFunction
  51. *
  52. *   Parameter:  hModule     - Handel
  53. *               wDataSeg    - Word
  54. *               wHeapSize   - Word
  55. *               lpszCmdLine - String
  56. *
  57. *   Return:       SHORT
  58. *                   TRUE
  59. *
  60. *   Comment:
  61. *-------------------------------------------------------------------------*/
  62. SHORT FAR PASCAL LibMain
  63. (HANDLE hModule, WORD wDataSeg, WORD wHeapSize, LPSTR lpszCmdLine)
  64. {
  65.     hInstance = hModule;
  66.     wDataSeg;
  67.     wHeapSize;
  68.     lpszCmdLine;
  69.  
  70.     if(wHeapSize > 0)
  71.         UnlockData(0);
  72.  
  73.     return TRUE;
  74. }
  75. /*-------------------------------------------------------------------------*
  76. *
  77. *   Function:   DLL ExitFuntion
  78. *
  79. *   Parameter:  nSystemExit - SHORT
  80. *
  81. *   Return:       SHORT
  82.                     nSystemExit - WEP_FREE_DLL
  83. *                                 WEP_SYSTEM_EXIT
  84.  
  85. *   Comment:
  86. *-------------------------------------------------------------------------*/
  87. SHORT DLLAPI WEP (SHORT nSystemExit)
  88. {
  89.     nSystemExit;
  90.     
  91.     return TRUE;
  92. }
  93. /*-------------------------------------------------------------------------*
  94. *
  95. *   Function:    TestFunction implements a simple calculation logic.   
  96. *
  97. *   Parameter:    hInBuf - HLSTR  
  98. *
  99. *   Return:        SHORT
  100. *
  101. *   Comment:
  102. *-------------------------------------------------------------------------*/
  103. SHORT DLLAPI VBDllTestProc (HLSTR hInBuf)
  104. {
  105. static     INPARAM            Param; 
  106.  
  107.         SHORT            nRet;
  108.         USHORT             nSize;
  109.         LPSTR             lpBuf;
  110.         HGLOBAL         hBuf;
  111.         
  112.     nRet = FALSE;
  113.     
  114. //    Get the size of inputbuffer and look if its equal to the 
  115. //    size of the structure. If not give up.             
  116.     nSize = VBGetHlstrLen(hInBuf);
  117.     if(nSize != sizeof(INPARAM))
  118.         return ERR_STRUCTSIZE;
  119. //    Allocate a global buffer and copy the VBString into it.        
  120.     hBuf = GlobalAlloc(GPTR, nSize + 1);
  121.     lpBuf = (LPSTR)GlobalLock(hBuf);
  122.     VBGetHlstr(hInBuf, (LPVOID)lpBuf, nSize);
  123. //    Now copy the different peaces into the structure
  124.     GetData(lpBuf, (LPINPARAM) &Param);
  125. /*-------------------------------------------------------------------------*
  126.     From now on you can use the structure to easely manipulate the data
  127.     like you would in a normal C program.
  128. *-------------------------------------------------------------------------*/
  129.     switch(Param.nTyp)
  130.     {
  131.         case 0:
  132.             Param.dblResult = Param.dblZ1 + Param.dblZ2; 
  133.             break;              
  134.         case 1:
  135.             Param.dblResult = Param.dblZ1 - Param.dblZ2;               
  136.             break;              
  137.         case 2:
  138.             Param.dblResult = Param.dblZ1 * Param.dblZ2;               
  139.             break;              
  140.         case 3:
  141.             Param.dblResult = Param.dblZ1 / Param.dblZ2;               
  142.             break;              
  143.         }
  144. /*-------------------------------------------------------------------------*
  145.     When your ready with this you can put the structure data back to VB 
  146. *-------------------------------------------------------------------------*/
  147. //    First back to the global buffer    
  148.     SetData(lpBuf, (LPINPARAM) &Param);
  149. //    Then back to VBString
  150.     VBSetHlstr(&hInBuf, lpBuf, nSize);
  151. //    Just some cleanup and we are ready.    
  152.     GlobalUnlock(hBuf);
  153.     GlobalFree(hBuf);
  154.     return nRet;
  155.         
  156. }
  157. /*-------------------------------------------------------------------------*
  158. *
  159. *   Function:    Copies the data from the inputbuffer (VBString)
  160.                 to a structure.   
  161. *
  162. *   Parameter:  lpBuf    - LPSTR
  163. *               lpParam - LPINPARAM
  164. *   Return:   
  165. *
  166. *   Comment:
  167. *-------------------------------------------------------------------------*/
  168. VOID FAR PASCAL GetData (LPSTR lpBuf, LPINPARAM lpParam)
  169. { 
  170. LONG     nSize, 
  171.         nPos;
  172.     
  173.     nSize = 0;
  174.     nPos = 0;   
  175.     nSize = sizeof(lpParam->nTyp);    
  176.     hmemcpy(&(lpParam->nTyp), (lpBuf + nPos), nSize);
  177.     nPos = nPos + nSize;  
  178.     nSize = sizeof(lpParam->dblZ1);    
  179.     hmemcpy(&(lpParam->dblZ1), (lpBuf + nPos), nSize);
  180.     nPos = nPos + nSize;  
  181.     nSize = sizeof(lpParam->dblZ2);    
  182.     hmemcpy(&(lpParam->dblZ2), (lpBuf + nPos), nSize);
  183.     nPos = nPos + nSize;  
  184.     nSize = sizeof(lpParam->dblResult);    
  185.     hmemcpy(&(lpParam->dblResult), (lpBuf + nPos), nSize);
  186.          
  187. }    
  188. /*-------------------------------------------------------------------------*
  189. *
  190. *   Function:    Copies the modified data back to the inputbuffer.   
  191. *
  192. *   Parameter:  lpBuf    - LPSTR
  193. *               lpParam - LPINPARAM
  194. *
  195. *   Return:   
  196. *
  197. *   Comment:
  198. *-------------------------------------------------------------------------*/
  199. VOID FAR PASCAL SetData (LPSTR lpBuf, LPINPARAM lpParam)
  200. {                          
  201. LONG     nSize = 0, 
  202.         nPos = 0;
  203.  
  204.     nSize = 0;
  205.     nPos = 0;                     
  206.     nSize = sizeof(lpParam->nTyp);    
  207.     hmemcpy((lpBuf + nPos), &(lpParam->nTyp), nSize);
  208.     nPos = nPos + nSize;  
  209.     nSize = sizeof(lpParam->dblZ1);    
  210.     hmemcpy((lpBuf + nPos), &(lpParam->dblZ1), nSize);
  211.     nPos = nPos + nSize;  
  212.     nSize = sizeof(lpParam->dblZ2);    
  213.     hmemcpy((lpBuf + nPos), &(lpParam->dblZ2), nSize);
  214.     nPos = nPos + nSize;  
  215.     nSize = sizeof(lpParam->dblResult);    
  216.     hmemcpy((lpBuf + nPos), &(lpParam->dblResult), nSize);
  217.     
  218. }    
  219.