home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 May / VPR9705A.ISO / VPR_DATA / PROGRAM / CBTRIAL / SETUP / DATA.Z / WOWNT32.H < prev    next >
C/C++ Source or Header  |  1997-02-14  |  10KB  |  265 lines
  1. /*++ BUILD Version: 0001    // Increment this if a change has global effects
  2.  
  3. Copyright (c) 1995, Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     wownt32.h
  8.  
  9. Abstract:
  10.  
  11.     Procedure declarations for functions in WOW32.DLL callable by
  12.     3rd-party 32-bit thunking code.
  13.  
  14. --*/
  15.  
  16. #ifndef _WOWNT32_
  17. #define _WOWNT32_
  18. #pragma option -b
  19.  
  20. #ifdef __cplusplus
  21. extern "C" {
  22. #endif /* __cplusplus */
  23.  
  24. //
  25. // 16:16 -> 0:32 Pointer translation.
  26. //
  27. // WOWGetVDMPointer will convert the passed in 16-bit address
  28. // to the equivalent 32-bit flat pointer.  If fProtectedMode
  29. // is TRUE, the function treats the upper 16 bits as a selector
  30. // in the local descriptor table.  If fProtectedMode is FALSE,
  31. // the upper 16 bits are treated as a real-mode segment value.
  32. // In either case the lower 16 bits are treated as the offset.
  33. //
  34. // The return value is NULL if the selector is invalid.
  35. //
  36. // NOTE:  Limit checking is not performed in the retail build
  37. // of Windows NT.  It is performed in the checked (debug) build
  38. // of WOW32.DLL, which will cause NULL to be returned when the
  39. // limit is exceeded by the supplied offset.
  40. //
  41.  
  42. LPVOID WINAPI WOWGetVDMPointer(DWORD vp, DWORD dwBytes,
  43.                                BOOL fProtectedMode);
  44.  
  45. //
  46. // The following two functions are here for compatibility with
  47. // Windows 95.  On Win95, the global heap can be rearranged,
  48. // invalidating flat pointers returned by WOWGetVDMPointer, while
  49. // a thunk is executing.  On Windows NT, the 16-bit VDM is completely
  50. // halted while a thunk executes, so the only way the heap will
  51. // be rearranged is if a callback is made to Win16 code.
  52. //
  53. // The Win95 versions of these functions call GlobalFix to
  54. // lock down a segment's flat address, and GlobalUnfix to
  55. // release the segment.
  56. //
  57. // The Windows NT implementations of these functions do *not*
  58. // call GlobalFix/GlobalUnfix on the segment, because there
  59. // will not be any heap motion unless a callback occurs.
  60. // If your thunk does callback to the 16-bit side, be sure
  61. // to discard flat pointers and call WOWGetVDMPointer again
  62. // to be sure the flat address is correct.
  63. //
  64.  
  65. LPVOID WINAPI WOWGetVDMPointerFix(DWORD vp, DWORD dwBytes,
  66.                                   BOOL fProtectedMode);
  67. VOID WINAPI WOWGetVDMPointerUnfix(DWORD vp);
  68.  
  69.  
  70. //
  71. // Win16 memory management.
  72. //
  73. // These functions can be used to manage memory in the Win16
  74. // heap.  The following four functions are identical to their
  75. // Win16 counterparts, except that they are called from Win32
  76. // code.
  77. //
  78.  
  79. WORD  WINAPI WOWGlobalAlloc16(WORD wFlags, DWORD cb);
  80. WORD  WINAPI WOWGlobalFree16(WORD hMem);
  81. DWORD WINAPI WOWGlobalLock16(WORD hMem);
  82. BOOL  WINAPI WOWGlobalUnlock16(WORD hMem);
  83.  
  84. //
  85. // The following three functions combine two common operations in
  86. // one switch to 16-bit mode.
  87. //
  88.  
  89. DWORD WINAPI WOWGlobalAllocLock16(WORD wFlags, DWORD cb, WORD *phMem);
  90. WORD  WINAPI WOWGlobalUnlockFree16(DWORD vpMem);
  91. DWORD WINAPI WOWGlobalLockSize16(WORD hMem, PDWORD pcb);
  92.  
  93. //
  94. // Yielding the Win16 nonpreemptive scheduler
  95. //
  96. // The following two functions are provided for Win32 code called
  97. // via Generic Thunks which needs to yield the Win16 scheduler so
  98. // that tasks in that VDM can execute while the thunk waits for
  99. // something to complete.  These two functions are functionally
  100. // identical to calling back to 16-bit code which calls Yield or
  101. // DirectedYield.
  102. //
  103.  
  104. VOID WINAPI WOWYield16(VOID);
  105. VOID WINAPI WOWDirectedYield16(WORD htask16);
  106.  
  107.  
  108. //
  109. // 16 <--> 32 Handle mapping functions.
  110. //
  111. // NOTE:  While some of these functions perform trivial
  112. // conversions, these functions must be used to maintain
  113. // compatibility with future versions of Windows NT which
  114. // may require different handle mapping.
  115. //
  116.  
  117. typedef enum _WOW_HANDLE_TYPE { /* WOW */
  118.     WOW_TYPE_HWND,
  119.     WOW_TYPE_HMENU,
  120.     WOW_TYPE_HDWP,
  121.     WOW_TYPE_HDROP,
  122.     WOW_TYPE_HDC,
  123.     WOW_TYPE_HFONT,
  124.     WOW_TYPE_HMETAFILE,
  125.     WOW_TYPE_HRGN,
  126.     WOW_TYPE_HBITMAP,
  127.     WOW_TYPE_HBRUSH,
  128.     WOW_TYPE_HPALETTE,
  129.     WOW_TYPE_HPEN,
  130.     WOW_TYPE_HACCEL,
  131.     WOW_TYPE_HTASK,
  132.     WOW_TYPE_FULLHWND
  133. } WOW_HANDLE_TYPE;
  134.  
  135. HANDLE WINAPI WOWHandle32 (WORD, WOW_HANDLE_TYPE);
  136. WORD WINAPI WOWHandle16 (HANDLE, WOW_HANDLE_TYPE);
  137.  
  138. #define HWND_32(h16)      ((HWND)      (WOWHandle32(h16, WOW_TYPE_HWND)))
  139. #define HMENU_32(h16)     ((HMENU)     (WOWHandle32(h16, WOW_TYPE_HMENU)))
  140. #define HDWP_32(h16)      ((HDWP)      (WOWHandle32(h16, WOW_TYPE_HDWP)))
  141. #define HDROP_32(h16)     ((HDROP)     (WOWHandle32(h16, WOW_TYPE_HDROP)))
  142. #define HDC_32(h16)       ((HDC)       (WOWHandle32(h16, WOW_TYPE_HDC)))
  143. #define HFONT_32(h16)     ((HFONT)     (WOWHandle32(h16, WOW_TYPE_HFONT)))
  144. #define HMETAFILE_32(h16) ((HMETAFILE) (WOWHandle32(h16, WOW_TYPE_HMETAFILE)))
  145. #define HRGN_32(h16)      ((HRGN)      (WOWHandle32(h16, WOW_TYPE_HRGN)))
  146. #define HBITMAP_32(h16)   ((HBITMAP)   (WOWHandle32(h16, WOW_TYPE_HBITMAP)))
  147. #define HBRUSH_32(h16)    ((HBRUSH)    (WOWHandle32(h16, WOW_TYPE_HBRUSH)))
  148. #define HPALETTE_32(h16)  ((HPALETTE)  (WOWHandle32(h16, WOW_TYPE_HPALETTE)))
  149. #define HPEN_32(h16)      ((HPEN)      (WOWHandle32(h16, WOW_TYPE_HPEN)))
  150. #define HACCEL_32(h16)      ((HACCEL)    (WOWHandle32(h16, WOW_TYPE_HACCEL)))
  151. #define HTASK_32(h16)      ((DWORD)     (WOWHandle32(h16, WOW_TYPE_HTASK)))
  152. #define FULLHWND_32(h16)  ((HWND)      (WOWHandle32(h16, WOW_TYPE_FULLHWND)))
  153.  
  154. #define HWND_16(h32)      (WOWHandle16(h32, WOW_TYPE_HWND))
  155. #define HMENU_16(h32)     (WOWHandle16(h32, WOW_TYPE_HMENU))
  156. #define HDWP_16(h32)      (WOWHandle16(h32, WOW_TYPE_HDWP))
  157. #define HDROP_16(h32)     (WOWHandle16(h32, WOW_TYPE_HDROP))
  158. #define HDC_16(h32)       (WOWHandle16(h32, WOW_TYPE_HDC))
  159. #define HFONT_16(h32)     (WOWHandle16(h32, WOW_TYPE_HFONT))
  160. #define HMETAFILE_16(h32) (WOWHandle16(h32, WOW_TYPE_HMETAFILE))
  161. #define HRGN_16(h32)      (WOWHandle16(h32, WOW_TYPE_HRGN))
  162. #define HBITMAP_16(h32)   (WOWHandle16(h32, WOW_TYPE_HBITMAP))
  163. #define HBRUSH_16(h32)    (WOWHandle16(h32, WOW_TYPE_HBRUSH))
  164. #define HPALETTE_16(h32)  (WOWHandle16(h32, WOW_TYPE_HPALETTE))
  165. #define HPEN_16(h32)      (WOWHandle16(h32, WOW_TYPE_HPEN))
  166. #define HACCEL_16(h32)      (WOWHandle16(h32, WOW_TYPE_HACCEL))
  167. #define HTASK_16(h32)      (WOWHandle16(h32, WOW_TYPE_HTASK))
  168.  
  169. //
  170. // Generic Callbacks.
  171. //
  172. // WOWCallback16 can be used in Win32 code called
  173. // from 16-bit (such as by using Generic Thunks) to call back to
  174. // the 16-bit side.  The function called must be declared similarly
  175. // to the following:
  176. //
  177. // LONG FAR PASCAL CallbackRoutine(DWORD dwParam);
  178. //
  179. // If you are passing a pointer, declare the parameter as such:
  180. //
  181. // LONG FAR PASCAL CallbackRoutine(VOID FAR *vp);
  182. //
  183. // NOTE: If you are passing a pointer, you'll need to get the
  184. // pointer using WOWGlobalAlloc16 or WOWGlobalAllocLock16
  185. //
  186. // If the function called returns a WORD instead of a DWORD, the
  187. // upper 16 bits of the return value is undefined.  Similarly, if
  188. // the function called has no return value, the entire return value
  189. // is undefined.
  190. //
  191. // WOWCallback16Ex allows any combination of arguments up to
  192. // WCB16_MAX_CBARGS bytes total to be passed to the 16-bit routine.
  193. // cbArgs is used to properly clean up the 16-bit stack after calling
  194. // the routine.  Regardless of the value of cbArgs, WCB16_MAX_CBARGS
  195. // bytes will always be copied from pArgs to the 16-bit stack.  If
  196. // pArgs is less than WCB16_MAX_CBARGS bytes from the end of a page,
  197. // and the next page is inaccessible, WOWCallback16Ex will incur an
  198. // access violation.
  199. //
  200. // If cbArgs is larger than the WCB16_MAX_ARGS which the running
  201. // system supports, the function returns FALSE and GetLastError
  202. // returns ERROR_INVALID_PARAMETER.  Otherwise the function
  203. // returns TRUE and the DWORD pointed to by pdwRetCode contains
  204. // the return code from the callback routine.  If the callback
  205. // routine returns a WORD, the HIWORD of the return code is
  206. // undefined and should be ignored using LOWORD(dwRetCode).
  207. //
  208. // WOWCallback16Ex can call routines using the PASCAL and CDECL
  209. // calling conventions.  The default is to use the PASCAL
  210. // calling convention.  To use CDECL, pass WCB16_CDECL in the
  211. // dwFlags parameter.
  212. //
  213. // The arguments pointed to by pArgs must be in the correct
  214. // order for the callback routine's calling convention.
  215. // To call the PASCAL routine SetWindowText,
  216. //
  217. // LONG FAR PASCAL SetWindowText(HWND hwnd, LPCSTR lpsz);
  218. //
  219. // pArgs would point to an array of words:
  220. //
  221. // WORD SetWindowTextArgs[] = {OFFSETOF(lpsz), SELECTOROF(lpsz), hwnd};
  222. //
  223. // In other words, the arguments are placed in the array in reverse
  224. // order with the least significant word first for DWORDs and offset
  225. // first for FAR pointers.
  226. //
  227. // To call the CDECL routine wsprintf, for example
  228. //
  229. // LPSTR lpszFormat = "%d %s";
  230. // int _cdecl wsprintf(lpsz, lpszFormat, nValue. lpszString);
  231. //
  232. // pArgs would point to the array:
  233. //
  234. // WORD wsprintfArgs[] = {OFFSETOF(lpsz), SELECTOROF(lpsz),
  235. //                        OFFSETOF(lpszFormat), SELECTOROF(lpszFormat),
  236. //                        nValue,
  237. //                        OFFSETOF(lpszString), SELECTOROF(lpszString)};
  238. //
  239. // In other words, the arguments are placed in the array in the order
  240. // listed in the function prototype with the least significant word
  241. // first for DWORDs and offset first for FAR pointers.
  242. //
  243.  
  244. DWORD WINAPI WOWCallback16(DWORD vpfn16, DWORD dwParam);
  245.  
  246. #define WCB16_MAX_CBARGS (16)
  247.  
  248. #define WCB16_PASCAL     (0x0)
  249. #define WCB16_CDECL      (0x1)
  250.  
  251. BOOL WINAPI WOWCallback16Ex(
  252.                 DWORD  vpfn16,
  253.                 DWORD  dwFlags,
  254.                 DWORD  cbArgs,
  255.                 PVOID  pArgs,
  256.                 PDWORD pdwRetCode
  257.                 );
  258.  
  259. #ifdef __cplusplus
  260. }
  261. #endif /* __cplusplus */
  262.  
  263. #pragma option -b.
  264. #endif /* !_WOWNT32_ */
  265.