home *** CD-ROM | disk | FTP | other *** search
/ On Hand / On_Hand_From_Softbank_1994_Release_2_Disc_1_1994.iso / 00091 / s / rhllapi.h_ / RHLLAPI.H
Text File  |  1993-08-26  |  11KB  |  275 lines
  1. /*-------------------------------------------------------------------*/
  2. /*                                     */
  3. /*         User Definitions for the RHLLAPI DLL             */
  4. /*                                     */
  5. /*-------------------------------------------------------------------*/
  6. /*                                     */
  7. /*     (c) Copyright 1983,93 by Relay Technology Inc.          */
  8. /*         All rights reserved                     */
  9. /*                                     */
  10. /*-------------------------------------------------------------------*/
  11.  
  12. /*-------------------------------------------------------------------*/
  13. /*                                     */
  14. /*                Module History                 */
  15. /*                                     */
  16. /*-------------------------------------------------------------------*/
  17. /*                                     */
  18. /* Latest Revision -                             */
  19. /*                                     */
  20. /*     $Revision:   5.3  $                         */
  21. /*                                     */
  22. /* Modification Log -                             */
  23. /*                                     */
  24. /*     F1911V60 Changed copyright                     */
  25. /*          by MAA on 08/26/93                     */
  26. /*     F0147V51 Fix HLLAPI DLL interface.                 */
  27. /*          by REB on 09/13/91                     */
  28. /*     M0146V51 Swaped RhllApi.h with RhllDef.h             */
  29. /*          by REB on 09/12/91                     */
  30. /*                                     */
  31. /*-------------------------------------------------------------------*/
  32. /*                                     */
  33. /* Notes -                                 */
  34. /*     1. Before calling any of the routines in this library         */
  35. /*        the function HLL_Initialize must be called to         */
  36. /*        establish communication with the Relay Application.      */
  37. /*        before quitting the application which called         */
  38. /*        HLL_Initialize the function HLL_Terminate must be called */
  39. /*        so that other applications will be allowed to communicate*/
  40. /*        with RELAY.                          */
  41. /*                                     */
  42. /*     2. To use the functions in this library link your         */
  43. /*        application with the library "rhllapi.lib".              */
  44. /*        For example:                         */
  45. /*        link /NOP/NOD hlltest,,,rhllapi libw mlibcew, hlltest.Def*/
  46. /*                                     */
  47. /*-------------------------------------------------------------------*/
  48.  
  49. /*-------------------------------------------------------------------*/
  50. /*                                     */
  51. /*              H L L _ I n i t i a l i z e             */
  52. /*                                     */
  53. /*-------------------------------------------------------------------*/
  54. /*                                     */
  55. /*  Procedure -                              */
  56. /*                                     */
  57.       WORD FAR PASCAL HLL_Initialize(HWND hOwner);
  58. /*                                     */
  59. /*  Function -                                 */
  60. /*                                     */
  61. /*     Initialize HLLAPI interface for an application.         */
  62. /*                                     */
  63. /*  Arguments -                              */
  64. /*                                     */
  65. /*     hOwner - Owner window handle, or NULL for none.         */
  66. /*                                     */
  67. /*  Returned value -                             */
  68. /*                                     */
  69. /*     Session number if initialization has been completed,         */
  70. /*     or 0 if initialization has failed.                 */
  71. /*                                     */
  72. /*  Notes -                                 */
  73. /*                                     */
  74. /*     1. This entry point performs HLLAPI initialization for      */
  75. /*        an instance of an application.                 */
  76. /*                                     */
  77. /*     2. The "session number" returned from this call is          */
  78. /*        currently always 1: this value must be passed to         */
  79. /*        other HLLAPI procedures to insure compatibility         */
  80. /*        with future releases.                     */
  81. /*                                     */
  82. /*     3. A hidden window of class "RHLLAPIWND" is created for     */
  83. /*        use in DDE communications only. If desired, this         */
  84. /*        window may be owned by a window belonging to the         */
  85. /*        calling application. If an owner window handle is         */
  86. /*        specified, the HLL_Terminate function will be         */
  87. /*        performed automatically when that window is destroyed.   */
  88. /*                                     */
  89. /*-------------------------------------------------------------------*/
  90.  
  91. /*-------------------------------------------------------------------*/
  92. /*                                     */
  93. /*               H L L _ T e r m i n a t e             */
  94. /*                                     */
  95. /*-------------------------------------------------------------------*/
  96. /*                                     */
  97. /*  Procedure -                              */
  98. /*                                     */
  99.       int FAR PASCAL HLL_Terminate(WORD Sesno);
  100. /*                                     */
  101. /*  Function -                                 */
  102. /*                                     */
  103. /*     Terminate HLLAPI interface for an application.          */
  104. /*                                     */
  105. /*  Arguments -                              */
  106. /*                                     */
  107. /*     Sesno -  Session number to be terminated.             */
  108. /*                                     */
  109. /*  Returned value -                             */
  110. /*                                     */
  111. /*     = 0 if termination was successful, or                 */
  112. /*     > 0 if the interface is not active.                 */
  113. /*                                     */
  114. /*  Notes -                                 */
  115. /*                                     */
  116. /*     1. This entry point performs HLLAPI termination for         */
  117. /*        an instance of an application.                 */
  118. /*                                     */
  119. /*     2. This routine sends a WM_DDE_TERMINATE request to RELAY.  */
  120. /*        A SendMessage call is used for this instead of the usual */
  121. /*        Message so that RELAY can process it immediately         */
  122. /*        (the WM_DDE_TERMINATE reply from RELAY is ignored).      */
  123. /*                                     */
  124. /*-------------------------------------------------------------------*/
  125.  
  126. /*-------------------------------------------------------------------*/
  127. /*                                     */
  128. /*             H L L _ E x e c u t e                 */
  129. /*                                     */
  130. /*-------------------------------------------------------------------*/
  131. /*                                     */
  132. /*  Procedure -                              */
  133. /*                                     */
  134.      int FAR PASCAL HLL_Execute(WORD  Sesno,
  135.                     int   Function,
  136.                     WORD  wParam,
  137.                     LPSTR lpStrParm,
  138.                     int   ParmLen);
  139. /*                                     */
  140. /*  Function -                                 */
  141. /*                                     */
  142. /*     Start a HLLAPI function executing.                 */
  143. /*                                     */
  144. /*  Arguments -                              */
  145. /*                                     */
  146. /*     Sesno - Session number from HLL_Initialize call.         */
  147. /*     Function -  HLLAPI function number.                 */
  148. /*     wParam - Word parameter value for HLLAPI function.         */
  149. /*     lpStrParam -  Pointer to parameter string or buffer.         */
  150. /*     ParmLen -  Length of parameter string or buffer.         */
  151. /*                                     */
  152. /*  Returned value -                             */
  153. /*                                     */
  154. /*     =0 if the function has been started OK, or             */
  155. /*     >0 if the function cannot be started.                 */
  156. /*                                     */
  157. /*  Notes -                                 */
  158. /*                                     */
  159. /*     1. This entry point starts a HLLAPI function executing.     */
  160. /*        A DDE message is sent to RELAY identifying the         */
  161. /*        request and its parameters.                  */
  162. /*                                     */
  163. /*-------------------------------------------------------------------*/
  164.  
  165. /*-------------------------------------------------------------------*/
  166. /*                                     */
  167. /*              H L L _ S t a t u s                 */
  168. /*                                     */
  169. /*-------------------------------------------------------------------*/
  170. /*                                     */
  171. /*  Procedure -                              */
  172. /*                                     */
  173.      int FAR PASCAL HLL_Status(WORD Sesno,
  174.                    LPINT lpHPBRETC,
  175.                    LPWORD lpHPBLEN);
  176. /*                                     */
  177. /*  Function -                                 */
  178. /*                                     */
  179. /*     Query the status of the last HLLAPI function executed.      */
  180. /*                                     */
  181. /*  Arguments -                              */
  182. /*                                     */
  183. /*     Sesno - Session number from HLL_Initialize call.         */
  184. /*     lpHPBRETC - Pointer to variable for HLLAPI return code      */
  185. /*             (HPBRETC).                      */
  186. /*     lpHPBLEN -  Pointer to variable for returned HPBLEN value.  */
  187. /*                                     */
  188. /*  Returned value -                             */
  189. /*                                     */
  190. /*     0 if the function is still executing, or             */
  191. /*     1 if the HLLAPI interface is not active, or             */
  192. /*     2 if the function has been completed.                 */
  193. /*                                     */
  194. /*  Notes -                                 */
  195. /*                                     */
  196. /*     1. This entry point returns the status of the last         */
  197. /*        HLLAPI function executed.                     */
  198. /*                                     */
  199. /*-------------------------------------------------------------------*/
  200.  
  201. /*-------------------------------------------------------------------*/
  202. /*                                     */
  203. /*                H L L _ W a i t                 */
  204. /*                                     */
  205. /*-------------------------------------------------------------------*/
  206. /*                                     */
  207. /*  Procedure -                              */
  208. /*                                     */
  209.      int FAR PASCAL HLL_Wait(WORD Sesno,
  210.                  LPINT lpHPBRETC,
  211.                  LPWORD lpHPBLEN);
  212. /*                                     */
  213. /*  Function -                                 */
  214. /*                                     */
  215. /*     Wait for a HLLAPI function to complete.             */
  216. /*                                     */
  217. /*  Arguments -                              */
  218. /*                                     */
  219. /*     Sesno - Session number from HLL_Initialize call.         */
  220. /*     lpHPBRETC -  Pointer to variable for HLLAPI return code     */
  221. /*              (HPBRETC).                     */
  222. /*     lpHPBLEN -  Pointer to variable for returned HPBLEN value.  */
  223. /*                                     */
  224. /*  Returned value -                             */
  225. /*                                     */
  226. /*     0 if no function was active on entry here, or             */
  227. /*     1 if the HLLAPI interface is not active, or             */
  228. /*     2 if the function has been completed.                 */
  229. /*                                     */
  230. /*  Notes -                                 */
  231. /*                                     */
  232. /*     1. This entry point waits for the completion of a         */
  233. /*        HLLAPI function request.                     */
  234. /*                                     */
  235. /*-------------------------------------------------------------------*/
  236.  
  237. /*-------------------------------------------------------------------*/
  238. /*                                     */
  239. /*                H L L C                  */
  240. /*                                     */
  241. /*-------------------------------------------------------------------*/
  242. /*                                     */
  243. /*  Procedure -                              */
  244. /*                                     */
  245.      int FAR PASCAL HLLC(LPINT lpFunction,
  246.                  LPSTR lpStrParm,
  247.                  LPINT lpParmLen,
  248.                  LPWORD lpRetCode);
  249. /*                                     */
  250. /*  Function -                                 */
  251. /*                                     */
  252. /*     Executes and waits for a HLLAPI function.             */
  253. /*                                     */
  254. /*  Arguments -                              */
  255. /*                                     */
  256. /*     lpFunction - Pointer to HLLAPI function number.         */
  257. /*     lpStrParam - Pointer to parameter string or buffer.         */
  258. /*     lpParamLen - Pointer to length of parameter string or buffer*/
  259. /*     lpRetCode - Pointer to word return code (also used to pass a*/
  260. /*        word parameter to certain HLLAPI functions).         */
  261. /*                                     */
  262. /*  Returned value -                             */
  263. /*                                     */
  264. /*     =0 if the function has been completed, or             */
  265. /*     >0 if the function could not be started.             */
  266. /*                                     */
  267. /*  Notes -                                 */
  268. /*                                     */
  269. /*     1. This entry point executes a HLLAPI function for session  */
  270. /*        1 and waits for its completion.                 */
  271. /*                                     */
  272. /*-------------------------------------------------------------------*/
  273. #define hllc HLLC
  274.  
  275.