Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1027 lines
25 KiB

  1. /*++
  2. *
  3. * WOW v1.0
  4. *
  5. * Copyright (c) 1991, Microsoft Corporation
  6. *
  7. * WGDI31.C
  8. * WOW32 16-bit Win 3.1 GDI API support
  9. *
  10. * History:
  11. * Created 16-Mar-1992 by Chandan S. Chauhan (ChandanC)
  12. *
  13. --*/
  14. #include "precomp.h"
  15. #pragma hdrstop
  16. #include "wowgdip.h"
  17. MODNAME(wgdi31.c);
  18. // This must be removed POSTBETA 2 for sure. We should be using common defines between
  19. // GDI and WOW. ChandanC 5/27/94.
  20. #define NOFIRSTSAVE 0x7FFFFFFE
  21. #define ADD_MSTT 0x7FFFFFFD
  22. // located in wgdi.c
  23. extern void SendFormFeedHack(HDC hdc);
  24. extern void RemoveFormFeedHack(HDC hdc);
  25. ULONG FASTCALL WG32AbortDoc(PVDMFRAME pFrame)
  26. {
  27. ULONG ul;
  28. HANDLE hdc32;
  29. register PABORTDOC16 parg16;
  30. GETARGPTR(pFrame, sizeof(ABORTDOC16), parg16);
  31. hdc32 = HDC32(parg16->f1);
  32. // remove any buffered data streams.
  33. if(CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_FORMFEEDHACK) {
  34. RemoveFormFeedHack(hdc32);
  35. }
  36. ul = GETINT16(AbortDoc(hdc32));
  37. if ((INT)ul < 0) {
  38. WOW32ASSERT ("WOW::WG32AbortDoc: Failed\n");
  39. }
  40. FREEARGPTR(parg16);
  41. RETURN(ul);
  42. }
  43. ULONG FASTCALL WG32CreateScalableFontResource(PVDMFRAME pFrame)
  44. {
  45. ULONG ul;
  46. PSZ t2;
  47. PSZ t3;
  48. PSZ t4;
  49. DWORD fHidden;
  50. register PCREATESCALABLEFONTRESOURCE16 parg16;
  51. GETARGPTR(pFrame, sizeof(CREATESCALABLEFONTRESOURCE16), parg16);
  52. GETPSZPTR(parg16->f2, t2);
  53. GETPSZPTR(parg16->f3, t3);
  54. GETPSZPTR(parg16->f4, t4);
  55. // We need to convert this param to 2 if the app gives 1. This tells GDI
  56. // to embed client TID in the private (hidden) font.
  57. //
  58. fHidden = (parg16->f1 == 1) ? 2 : (parg16->f1);
  59. ul = GETBOOL16(CreateScalableFontResource(fHidden,
  60. t2,
  61. t3,
  62. t4));
  63. FREEARGPTR(parg16);
  64. RETURN(ul);
  65. }
  66. ULONG FASTCALL WG32EndDoc(PVDMFRAME pFrame)
  67. {
  68. ULONG ul;
  69. HANDLE hdc32;
  70. register PENDDOC16 parg16;
  71. GETARGPTR(pFrame, sizeof(ENDDOC16), parg16);
  72. hdc32 = HDC32(parg16->f1);
  73. // send any buffered data streams to the printer.
  74. if(CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_FORMFEEDHACK) {
  75. SendFormFeedHack(hdc32);
  76. }
  77. ul = GETINT16(EndDoc(hdc32));
  78. FREEARGPTR(parg16);
  79. RETURN(ul);
  80. }
  81. ULONG FASTCALL WG32EnumFontFamilies(PVDMFRAME pFrame)
  82. {
  83. return( W32EnumFontHandler(pFrame, TRUE) );
  84. }
  85. ULONG FASTCALL WG32GetAspectRatioFilterEx(PVDMFRAME pFrame)
  86. {
  87. ULONG ul;
  88. SIZE AspectRatio;
  89. register PGETASPECTRATIOFILTEREX16 parg16;
  90. GETARGPTR(pFrame, sizeof(GETASPECTRATIOFILTEREX16), parg16);
  91. ul = GETBOOL16(GetAspectRatioFilterEx(HDC32(parg16->f1), &AspectRatio));
  92. PUTSIZE16(parg16->f2, &AspectRatio);
  93. FREEARGPTR(parg16);
  94. RETURN(ul);
  95. }
  96. ULONG FASTCALL WG32GetBitmapDimensionEx(PVDMFRAME pFrame)
  97. {
  98. ULONG ul;
  99. SIZE Dimension;
  100. register PGETBITMAPDIMENSIONEX16 parg16;
  101. GETARGPTR(pFrame, sizeof(GETBITMAPDIMENSIONEX16), parg16);
  102. ul = GETBOOL16(GetBitmapDimensionEx(HBITMAP32(parg16->f1), &Dimension));
  103. PUTSIZE16(parg16->f2, &Dimension);
  104. FREEARGPTR(parg16);
  105. RETURN (ul);
  106. }
  107. ULONG FASTCALL WG32GetBoundsRect(PVDMFRAME pFrame)
  108. {
  109. ULONG ul = 0;
  110. RECT Bounds;
  111. register PGETBOUNDSRECT16 parg16;
  112. GETARGPTR(pFrame, sizeof(GETBOUNDSRECT16), parg16);
  113. ul = GETUINT16(GetBoundsRect(HDC32(parg16->f1),
  114. &Bounds,
  115. UINT32(parg16->f3)));
  116. //
  117. // Win16 GetBoundsRect always returns DCB_SET or DCB_RESET.
  118. //
  119. ul = (ul & DCB_SET) ? DCB_SET : DCB_RESET;
  120. PUTRECT16(parg16->f2, &Bounds);
  121. FREEARGPTR(parg16);
  122. RETURN (ul);
  123. }
  124. ULONG FASTCALL WG32GetBrushOrgEx(PVDMFRAME pFrame)
  125. {
  126. ULONG ul;
  127. POINT Point;
  128. register PGETBRUSHORGEX16 parg16;
  129. GETARGPTR(pFrame, sizeof(GETBRUSHORGEX16), parg16);
  130. ul = GETBOOL16(GetBrushOrgEx(HDC32(parg16->f1), &Point));
  131. PUTPOINT16(parg16->f2, &Point);
  132. FREEARGPTR(parg16);
  133. RETURN (ul);
  134. }
  135. ULONG FASTCALL WG32GetCharABCWidths(PVDMFRAME pFrame)
  136. {
  137. ULONG ul=0;
  138. LPABC lpAbc;
  139. WORD cb;
  140. register PGETCHARABCWIDTHS16 parg16;
  141. GETARGPTR(pFrame, sizeof(GETCHARABCWIDTHS16), parg16);
  142. cb = WORD32(parg16->f3) - WORD32(parg16->f2) + 1;
  143. if (lpAbc = (LPABC) malloc_w (sizeof(ABC) * cb)) {
  144. ul = GETBOOL16(GetCharABCWidths(HDC32(parg16->f1),
  145. WORD32(parg16->f2),
  146. WORD32(parg16->f3),
  147. lpAbc));
  148. if (ul) {
  149. putabcpairs16(parg16->f4, cb, lpAbc);
  150. }
  151. free_w (lpAbc);
  152. }
  153. FREEARGPTR(parg16);
  154. RETURN (ul);
  155. }
  156. ULONG FASTCALL WG32GetCurrentPositionEx(PVDMFRAME pFrame)
  157. {
  158. ULONG ul;
  159. POINT Point;
  160. register PGETCURRENTPOSITIONEX16 parg16;
  161. GETARGPTR(pFrame, sizeof(GETCURRENTPOSITIONEX16), parg16);
  162. ul = GETBOOL16(GetCurrentPositionEx(HDC32(parg16->f1), &Point));
  163. PUTPOINT16(parg16->f2, &Point);
  164. FREEARGPTR(parg16);
  165. RETURN (ul);
  166. }
  167. ULONG FASTCALL WG32GetGlyphOutline(PVDMFRAME pFrame)
  168. {
  169. ULONG ul;
  170. LPSTR lpBuffer;
  171. MAT2 Matrix;
  172. GLYPHMETRICS Metrics;
  173. register PGETGLYPHOUTLINE16 parg16;
  174. GETARGPTR(pFrame, sizeof(GETGLYPHOUTLINE16), parg16);
  175. GETMAT2(parg16->f7, &Matrix);
  176. GETVDMPTR(parg16->f6, parg16->f5, lpBuffer);
  177. ul = GETDWORD16(GetGlyphOutlineWow(HDC32(parg16->f1),
  178. WORD32(parg16->f2),
  179. WORD32(parg16->f3),
  180. parg16->f4 ? &Metrics : (GLYPHMETRICS*)NULL,
  181. DWORD32(parg16->f5),
  182. lpBuffer,
  183. &Matrix));
  184. if ( FETCHDWORD(parg16->f4) != 0 ) {
  185. PUTGLYPHMETRICS16(FETCHDWORD(parg16->f4), &Metrics);
  186. }
  187. FREEVDMPTR(lpBuffer);
  188. FREEARGPTR(parg16);
  189. RETURN (ul);
  190. }
  191. ULONG FASTCALL WG32GetKerningPairs(PVDMFRAME pFrame)
  192. {
  193. ULONG ul;
  194. LPKERNINGPAIR lpkrnpair = NULL;
  195. register PGETKERNINGPAIRS16 parg16;
  196. GETARGPTR(pFrame, sizeof(GETKERNINGPAIRS16), parg16);
  197. if (FETCHDWORD(parg16->f3)) {
  198. lpkrnpair = (LPKERNINGPAIR) malloc_w (sizeof(KERNINGPAIR) * (parg16->f2));
  199. if (!lpkrnpair) {
  200. LOGDEBUG (0, ("WOW::WG32GetKeriningPairs: *** MALLOC failed ***\n"));
  201. FREEARGPTR(parg16);
  202. RETURN (0);
  203. }
  204. }
  205. ul = GetKerningPairs(HDC32(parg16->f1), parg16->f2, lpkrnpair);
  206. if (FETCHDWORD(parg16->f3)) {
  207. putkerningpairs16 (FETCHDWORD(parg16->f3), parg16->f2, lpkrnpair);
  208. free_w (lpkrnpair);
  209. }
  210. FREEARGPTR(parg16);
  211. RETURN (ul);
  212. }
  213. ULONG FASTCALL WG32GetOutlineTextMetrics(PVDMFRAME pFrame)
  214. {
  215. ULONG ul;
  216. register PGETOUTLINETEXTMETRICS16 parg16;
  217. UINT cb;
  218. UINT new_cb;
  219. VPOUTLINETEXTMETRIC16 vpotm;
  220. LPOUTLINETEXTMETRIC lpBuffer;
  221. GETARGPTR(pFrame, sizeof(GETOUTLINETEXTMETRICS16), parg16);
  222. vpotm = (VPOUTLINETEXTMETRIC16)FETCHDWORD(parg16->f3);
  223. new_cb = cb = FETCHWORD(parg16->f2);
  224. if ( vpotm ) {
  225. new_cb += sizeof(OUTLINETEXTMETRIC) - sizeof(OUTLINETEXTMETRIC16);
  226. if (!(lpBuffer = (LPOUTLINETEXTMETRIC)malloc_w(new_cb))) {
  227. FREEARGPTR(parg16);
  228. RETURN (0);
  229. }
  230. } else {
  231. lpBuffer = NULL;
  232. }
  233. ul = GETDWORD16(GetOutlineTextMetrics(HDC32(parg16->f1), new_cb, lpBuffer));
  234. if ( vpotm ) {
  235. PUTOUTLINETEXTMETRIC16(vpotm, cb, lpBuffer);
  236. free_w( lpBuffer );
  237. } else {
  238. if ( ul != 0 ) {
  239. ul -= sizeof(OUTLINETEXTMETRIC) - sizeof(OUTLINETEXTMETRIC16);
  240. }
  241. }
  242. FREEARGPTR(parg16);
  243. RETURN (ul);
  244. }
  245. ULONG FASTCALL WG32GetRasterizerCaps(PVDMFRAME pFrame)
  246. {
  247. ULONG ul;
  248. RASTERIZER_STATUS RStatus;
  249. register PGETRASTERIZERCAPS16 parg16;
  250. GETARGPTR(pFrame, sizeof(GETRASTERIZERCAPS16), parg16);
  251. ul = GETBOOL16(GetRasterizerCaps(&RStatus, INT32(parg16->f2)));
  252. PUTRASTERIZERSTATUS16(parg16->f1, &RStatus);
  253. FREEARGPTR(parg16);
  254. RETURN (ul);
  255. }
  256. #define PUTEXTSIZE16(vp, lp) \
  257. { \
  258. PSIZE16 p16; \
  259. GETVDMPTR(vp, sizeof(SIZE16), p16); \
  260. if (((lp)->cx|(lp)->cy) & ~SHRT_MAX) \
  261. { \
  262. if ((lp)->cx > SHRT_MAX) \
  263. STORESHORT(p16->cx, SHRT_MAX); \
  264. else \
  265. STORESHORT(p16->cx, (lp)->cx); \
  266. if ((lp)->cy > SHRT_MAX) \
  267. STORESHORT(p16->cy, SHRT_MAX); \
  268. else \
  269. STORESHORT(p16->cy, (lp)->cy); \
  270. } \
  271. else \
  272. { \
  273. STORESHORT(p16->cx, (lp)->cx); \
  274. STORESHORT(p16->cy, (lp)->cy); \
  275. } \
  276. FREEVDMPTR(p16); \
  277. }
  278. ULONG FASTCALL WG32GetTextExtentPoint(PVDMFRAME pFrame)
  279. {
  280. ULONG ul;
  281. PSZ lpString;
  282. SIZE Size;
  283. register PGETTEXTEXTENTPOINT16 parg16;
  284. HDC hDC32;
  285. HDC hDCMenu = NULL;
  286. HGDIOBJ hOldFont;
  287. HGDIOBJ hFont = NULL;
  288. NONCLIENTMETRICS ncm;
  289. PTD ptd = CURRENTPTD();
  290. GETARGPTR(pFrame, sizeof(GETTEXTEXTENTPOINT16), parg16);
  291. GETPSZPTR(parg16->f2, lpString);
  292. hDC32 = HDC32(parg16->f1);
  293. // WP tutorial assumes that the font selected in the hDC for desktop window
  294. // (ie, result of GetDC(NULL)) is the same font as the font selected for
  295. // drawing the menu. Unfortunetly in SUR this is not true as the user can
  296. // select any font for the menu. So we remember the hDC returned for GetDC(0)
  297. // and check for it in GetTextExtentPoint. If the app does try to use it we
  298. // find the hDC for the current menu window and substitute that. When the app
  299. // does another GetDC or ReleaseDC we forget the hDC returned for the original
  300. // GetDC(0).
  301. if ((ptd->dwWOWCompatFlagsEx & WOWCFEX_FIXDCFONT4MENUSIZE) &&
  302. (parg16->f1 == ptd->ulLastDesktophDC) &&
  303. ((hDCMenu = GetDC(NULL)) != NULL) &&
  304. ((ncm.cbSize = sizeof(NONCLIENTMETRICS)) != 0) &&
  305. (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, (PVOID)&ncm, 0)) &&
  306. ((hFont = CreateFontIndirect(&(ncm.lfMenuFont))) != NULL)) {
  307. hOldFont = SelectObject(hDCMenu, hFont);
  308. hDC32 = hDCMenu;
  309. }
  310. ul = GETBOOL16(GetTextExtentPoint(hDC32,
  311. lpString,
  312. INT32(parg16->f3),
  313. &Size));
  314. if (hDCMenu != NULL) {
  315. if (hFont != NULL) {
  316. SelectObject(hDCMenu, hOldFont);
  317. DeleteObject(hFont);
  318. }
  319. ReleaseDC(NULL, hDCMenu);
  320. }
  321. PUTEXTSIZE16(parg16->f4, &Size);
  322. FREEARGPTR(parg16);
  323. RETURN (ul);
  324. }
  325. ULONG FASTCALL WG32GetViewportExtEx(PVDMFRAME pFrame)
  326. {
  327. ULONG ul;
  328. SIZE Size;
  329. register PGETVIEWPORTEXTEX16 parg16;
  330. GETARGPTR(pFrame, sizeof(GETVIEWPORTEXTEX16), parg16);
  331. ul = GETBOOL16(GetViewportExtEx(HDC32(parg16->f1), &Size));
  332. PUTSIZE16(parg16->f2, &Size);
  333. FREEARGPTR(parg16);
  334. RETURN (ul);
  335. }
  336. ULONG FASTCALL WG32GetViewportOrgEx(PVDMFRAME pFrame)
  337. {
  338. ULONG ul;
  339. POINT Point;
  340. register PGETVIEWPORTORGEX16 parg16;
  341. GETARGPTR(pFrame, sizeof(GETVIEWPORTORGEX16), parg16);
  342. ul = GETBOOL16(GetViewportOrgEx(HDC32(parg16->f1), &Point));
  343. PUTPOINT16(parg16->f2, &Point);
  344. FREEARGPTR(parg16);
  345. RETURN (ul);
  346. }
  347. ULONG FASTCALL WG32GetWindowExtEx(PVDMFRAME pFrame)
  348. {
  349. ULONG ul;
  350. SIZE Size;
  351. register PGETWINDOWEXTEX16 parg16;
  352. GETARGPTR(pFrame, sizeof(GETWINDOWEXTEX16), parg16);
  353. ul = GETBOOL16(GetWindowExtEx( HDC32(parg16->f1),&Size));
  354. PUTSIZE16(parg16->f2, &Size);
  355. FREEARGPTR(parg16);
  356. RETURN (ul);
  357. }
  358. ULONG FASTCALL WG32GetWindowOrgEx(PVDMFRAME pFrame)
  359. {
  360. ULONG ul;
  361. POINT Point;
  362. register PGETWINDOWORGEX16 parg16;
  363. GETARGPTR(pFrame, sizeof(GETWINDOWORGEX16), parg16);
  364. ul = GETBOOL16(GetWindowOrgEx(HDC32(parg16->f1), &Point));
  365. PUTPOINT16(parg16->f2, &Point);
  366. FREEARGPTR(parg16);
  367. RETURN (ul);
  368. }
  369. ULONG FASTCALL WG32MoveToEx(PVDMFRAME pFrame)
  370. {
  371. ULONG ul;
  372. POINT Point;
  373. LPPOINT lpPoint = NULL;
  374. register PMOVETOEX16 parg16;
  375. GETARGPTR(pFrame, sizeof(MOVETOEX16), parg16);
  376. if (parg16->f4) {
  377. lpPoint = &Point;
  378. }
  379. ul = GETBOOL16(MoveToEx(HDC32(parg16->f1),
  380. INT32(parg16->f2),
  381. INT32(parg16->f3),
  382. lpPoint));
  383. if (parg16->f4) {
  384. PUTPOINT16(parg16->f4, lpPoint);
  385. }
  386. FREEARGPTR(parg16);
  387. RETURN (ul);
  388. }
  389. ULONG FASTCALL WG32OffsetViewportOrgEx(PVDMFRAME pFrame)
  390. {
  391. ULONG ul;
  392. POINT Point;
  393. LPPOINT lpPoint = NULL;
  394. register POFFSETVIEWPORTORGEX16 parg16;
  395. GETARGPTR(pFrame, sizeof(OFFSETVIEWPORTEX16), parg16);
  396. if (parg16->f4) {
  397. lpPoint = &Point;
  398. }
  399. ul = GETBOOL16(OffsetViewportOrgEx(HDC32(parg16->f1),
  400. INT32(parg16->f2),
  401. INT32(parg16->f3),
  402. lpPoint));
  403. if (parg16->f4) {
  404. PUTPOINT16(parg16->f4, lpPoint);
  405. }
  406. FREEARGPTR(parg16);
  407. RETURN (ul);
  408. }
  409. ULONG FASTCALL WG32OffsetWindowOrgEx(PVDMFRAME pFrame)
  410. {
  411. ULONG ul;
  412. POINT Point;
  413. LPPOINT lpPoint = NULL;
  414. register POFFSETWINDOWORGEX16 parg16;
  415. GETARGPTR(pFrame, sizeof(OFFSETWINDOWORGEX16), parg16);
  416. if (parg16->f4) {
  417. lpPoint = &Point;
  418. }
  419. ul = GETBOOL16(OffsetWindowOrgEx(HDC32(parg16->f1),
  420. INT32(parg16->f2),
  421. INT32(parg16->f3),
  422. lpPoint));
  423. if (parg16->f4) {
  424. PUTPOINT16(parg16->f4, lpPoint);
  425. }
  426. FREEARGPTR(parg16);
  427. RETURN (ul);
  428. }
  429. ULONG FASTCALL WG32ResetDC(PVDMFRAME pFrame)
  430. {
  431. ULONG ul = 0;
  432. LPDEVMODE lpInitData;
  433. HANDLE hdc32;
  434. register PRESETDC16 parg16;
  435. GETARGPTR(pFrame, sizeof(RESETDC16), parg16);
  436. hdc32 = HDC32(parg16->f1);
  437. if( lpInitData = ThunkDevMode16to32(FETCHDWORD(parg16->f2)) ) {
  438. // send any buffered data streams.
  439. if(CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_FORMFEEDHACK) {
  440. SendFormFeedHack(hdc32);
  441. }
  442. ul = GETHDC16(ResetDC(hdc32, lpInitData));
  443. FREEDEVMODE32(lpInitData);
  444. }
  445. RETURN (ul);
  446. }
  447. ULONG FASTCALL WG32ScaleViewportExtEx(PVDMFRAME pFrame)
  448. {
  449. ULONG ul;
  450. SIZE Size;
  451. LPSIZE lpSize = NULL;
  452. register PSCALEVIEWPORTEXTEX16 parg16;
  453. GETARGPTR(pFrame, sizeof(SCALEVIEWPORTEXTEX16), parg16);
  454. if (parg16->f6) {
  455. lpSize = &Size;
  456. }
  457. ul = GETBOOL16(ScaleViewportExtEx(HDC32(parg16->f1),
  458. INT32(parg16->f2),
  459. INT32(parg16->f3),
  460. INT32(parg16->f4),
  461. INT32(parg16->f5),
  462. lpSize));
  463. if (parg16->f6) {
  464. PUTSIZE16(parg16->f6, lpSize);
  465. }
  466. FREEARGPTR(parg16);
  467. RETURN (ul);
  468. }
  469. ULONG FASTCALL WG32ScaleWindowExtEx(PVDMFRAME pFrame)
  470. {
  471. ULONG ul;
  472. SIZE Size;
  473. LPSIZE lpSize = NULL;
  474. register PSCALEWINDOWEXTEX16 parg16;
  475. GETARGPTR(pFrame, sizeof(SCALEWINDOWEXTEX16), parg16);
  476. if (parg16->f6) {
  477. lpSize = &Size;
  478. }
  479. ul = GETBOOL16(ScaleWindowExtEx(HDC32(parg16->f1),
  480. INT32(parg16->f2),
  481. INT32(parg16->f3),
  482. INT32(parg16->f4),
  483. INT32(parg16->f5),
  484. lpSize));
  485. if (parg16->f6) {
  486. PUTSIZE16(parg16->f6, lpSize);
  487. }
  488. FREEARGPTR(parg16);
  489. RETURN (ul);
  490. }
  491. ULONG FASTCALL WG32SetAbortProc(PVDMFRAME pFrame)
  492. {
  493. ULONG ul;
  494. register PSETABORTPROC16 parg16;
  495. GETARGPTR(pFrame, sizeof(SETABORTPROC16), parg16);
  496. ((PTDB)SEGPTR(pFrame->wTDB, 0))->TDB_vpfnAbortProc = FETCHDWORD(parg16->f2);
  497. ul = GETINT16(SetAbortProc(HDC32(parg16->f1), (ABORTPROC) W32AbortProc));
  498. FREEARGPTR(parg16);
  499. RETURN (ul);
  500. }
  501. ULONG FASTCALL WG32SetBitmapDimensionEx(PVDMFRAME pFrame)
  502. {
  503. ULONG ul;
  504. SIZE Size;
  505. LPSIZE lpSize = NULL;
  506. register PSETBITMAPDIMENSIONEX16 parg16;
  507. GETARGPTR(pFrame, sizeof(SETBITMAPDIMENSIONEX16), parg16);
  508. if (parg16->f4) {
  509. lpSize = &Size;
  510. }
  511. ul = GETBOOL16(SetBitmapDimensionEx(HBITMAP32(parg16->f1),
  512. INT32(parg16->f2),
  513. INT32(parg16->f3),
  514. lpSize));
  515. if (parg16->f4) {
  516. PUTSIZE16(parg16->f4, lpSize);
  517. }
  518. FREEARGPTR(parg16);
  519. RETURN (ul);
  520. }
  521. ULONG FASTCALL WG32SetBoundsRect(PVDMFRAME pFrame)
  522. {
  523. ULONG ul = 0;
  524. RECT rcBounds;
  525. register PSETBOUNDSRECT16 parg16;
  526. GETARGPTR(pFrame, sizeof(SETBOUNDSRECT16), parg16);
  527. GETRECT16(parg16->f2, &rcBounds);
  528. ul = GETWORD16(SetBoundsRect(HDC32(parg16->f1),
  529. &rcBounds,
  530. WORD32(parg16->f3)));
  531. FREEARGPTR(parg16);
  532. RETURN (ul);
  533. }
  534. #if 0 // implemented in gdi.exe
  535. ULONG FASTCALL WG32SetMetaFileBitsBetter(PVDMFRAME pFrame)
  536. {
  537. return(WG32SetMetaFileBits(pFrame));
  538. }
  539. #endif
  540. ULONG FASTCALL WG32SetViewportExtEx(PVDMFRAME pFrame)
  541. {
  542. ULONG ul;
  543. SIZE Size;
  544. LPSIZE lpSize = NULL;
  545. register PSETVIEWPORTEXTEX16 parg16;
  546. GETARGPTR(pFrame, sizeof(SETVIEWPORTEXTEX16), parg16);
  547. if (parg16->f4) {
  548. lpSize = &Size;
  549. }
  550. ul = GETBOOL16(SetViewportExtEx(HDC32(parg16->f1),
  551. INT32(parg16->f2),
  552. INT32(parg16->f3),
  553. lpSize));
  554. if (parg16->f4) {
  555. PUTSIZE16(parg16->f4, lpSize);
  556. }
  557. FREEARGPTR(parg16);
  558. RETURN (ul);
  559. }
  560. ULONG FASTCALL WG32SetViewportOrgEx(PVDMFRAME pFrame)
  561. {
  562. ULONG ul;
  563. POINT Point;
  564. LPPOINT lpPoint = NULL;
  565. register PSETVIEWPORTORGEX16 parg16;
  566. GETARGPTR(pFrame, sizeof(SETVIEWPORTORGEX16), parg16);
  567. if (parg16->f4) {
  568. lpPoint = &Point;
  569. }
  570. ul = GETBOOL16(SetViewportOrgEx(HDC32(parg16->f1),
  571. INT32(parg16->f2),
  572. INT32(parg16->f3),
  573. lpPoint));
  574. if (parg16->f4) {
  575. PUTPOINT16(parg16->f4, lpPoint);
  576. }
  577. FREEARGPTR(parg16);
  578. RETURN (ul);
  579. }
  580. ULONG FASTCALL WG32SetWindowExtEx(PVDMFRAME pFrame)
  581. {
  582. ULONG ul;
  583. SIZE Size;
  584. LPSIZE lpSize = NULL;
  585. register PSETWINDOWEXTEX16 parg16;
  586. GETARGPTR(pFrame, sizeof(SETWINDOWEXTEX16), parg16);
  587. if (parg16->f4) {
  588. lpSize = &Size;
  589. }
  590. ul = GETBOOL16(SetWindowExtEx(HDC32(parg16->f1),
  591. INT32(parg16->f2),
  592. INT32(parg16->f3),
  593. lpSize));
  594. if (parg16->f4) {
  595. PUTSIZE16(parg16->f4, lpSize);
  596. }
  597. FREEARGPTR(parg16);
  598. RETURN (ul);
  599. }
  600. ULONG FASTCALL WG32SetWindowOrgEx(PVDMFRAME pFrame)
  601. {
  602. ULONG ul;
  603. POINT Point;
  604. LPPOINT lpPoint = NULL;
  605. register PSETWINDOWORGEX16 parg16;
  606. GETARGPTR(pFrame, sizeof(SETWINDOWORGEX16), parg16);
  607. if (parg16->f4) {
  608. lpPoint = &Point;
  609. }
  610. ul = GETBOOL16(SetWindowOrgEx(HDC32(parg16->f1),
  611. INT32(parg16->f2),
  612. INT32(parg16->f3),
  613. lpPoint));
  614. if (parg16->f4) {
  615. PUTPOINT16(parg16->f4, lpPoint);
  616. }
  617. FREEARGPTR(parg16);
  618. RETURN (ul);
  619. }
  620. ULONG FASTCALL WG32StartDoc(PVDMFRAME pFrame)
  621. {
  622. ULONG ul;
  623. VPVOID vpDocName;
  624. VPVOID vpOutput;
  625. DOCINFO DocInfo;
  626. LPDOCINFO16 pdi16;
  627. HANDLE hdc32;
  628. register PSTARTDOC16 parg16;
  629. GETARGPTR(pFrame, sizeof(STARTDOC16), parg16);
  630. GETVDMPTR(parg16->f2, sizeof(DOCINFO16), pdi16);
  631. //
  632. // Win32 StartDoc depends on having the correct current directory
  633. // when printing to FILE: (which pops up for a filename).
  634. //
  635. UpdateDosCurrentDirectory(DIR_DOS_TO_NT);
  636. DocInfo.cbSize = sizeof(DOCINFO);
  637. vpDocName = FETCHDWORD(pdi16->lpszDocName);
  638. vpOutput = FETCHDWORD(pdi16->lpszOutput);
  639. GETPSZPTR(vpDocName, DocInfo.lpszDocName);
  640. GETPSZPTR(vpOutput, DocInfo.lpszOutput);
  641. DocInfo.lpszDatatype = NULL;
  642. DocInfo.fwType = 0;
  643. FREEVDMPTR(pdi16);
  644. hdc32 = HDC32(parg16->f1);
  645. ul = GETINT16(StartDoc(hdc32, &DocInfo));
  646. if (CURRENTPTD()->dwWOWCompatFlags & WOWCF_NOFIRSTSAVE) {
  647. int l;
  648. char szBuf[80];
  649. if ((l = ExtEscape(hdc32,
  650. GETTECHNOLOGY,
  651. 0,
  652. NULL,
  653. sizeof(szBuf),
  654. szBuf)) > 0) {
  655. if (!WOW32_stricmp(szBuf, szPostscript)) {
  656. l = ExtEscape(hdc32,
  657. NOFIRSTSAVE,
  658. 0,
  659. NULL,
  660. 0,
  661. NULL);
  662. // This HACK is for FH4.0 only. If you have any questions
  663. // talk to PingW or ChandanC.
  664. // July 21st 1994.
  665. //
  666. if (CURRENTPTD()->dwWOWCompatFlags & WOWCF_ADD_MSTT) {
  667. l = ExtEscape(hdc32,
  668. ADD_MSTT,
  669. 0,
  670. NULL,
  671. 0,
  672. NULL);
  673. }
  674. }
  675. }
  676. }
  677. FREEPSZPTR(DocInfo.lpszDocName);
  678. FREEPSZPTR(DocInfo.lpszOutput);
  679. FREEARGPTR(parg16);
  680. RETURN (ul);
  681. }
  682. // InquireVisRgn is an undocumented Win 3.1 API. This code has been
  683. // suggested by ChuckWh. If this does not fix the FileMaker Pro 2.0
  684. // problem, then ChuckWh would be providing us with an private entry
  685. // point.
  686. // ChandanC 7th Feb 93
  687. //
  688. HRGN ghrgnVis = NULL;
  689. ULONG FASTCALL WG32InquireVisRgn(PVDMFRAME pFrame)
  690. {
  691. register PINQUIREVISRGN16 parg16;
  692. extern int GetRandomRgn(HDC hdc, HRGN hrgn, int cmd);
  693. GETARGPTR(pFrame, sizeof(INQUIREVISRGN16), parg16);
  694. // call special gdi entry point to get copy of vis rgn
  695. GetRandomRgn(HDC32(parg16->f1), ghrgnVis, 4);
  696. FREEARGPTR(parg16);
  697. RETURN (GETHRGN16(ghrgnVis));
  698. }
  699. BOOL InitVisRgn()
  700. {
  701. ghrgnVis = CreateRectRgn(0,0,0,0);
  702. return(ghrgnVis != NULL);
  703. }
  704. VOID putabcpairs16(VPABC16 vpAbc, UINT cb, LPABC lpAbc)
  705. {
  706. UINT i;
  707. register PABC16 pAbc16;
  708. GETVDMPTR(vpAbc, sizeof(ABC16), pAbc16);
  709. for (i=0; i < cb; i++) {
  710. pAbc16[i].abcA = (INT16) lpAbc[i].abcA;
  711. pAbc16[i].abcB = (WORD) lpAbc[i].abcB;
  712. pAbc16[i].abcC = (INT16) lpAbc[i].abcC;
  713. }
  714. FLUSHVDMPTR(vpAbc, sizeof(ABC16), pAbc16);
  715. FREEVDMPTR(pAbc16);
  716. }
  717. ULONG FASTCALL WG32GetClipRgn(PVDMFRAME pFrame)
  718. {
  719. register PGETCLIPRGN16 parg16;
  720. // this is a private win3.1 entry pointed defined as HRGN GetClipRgn(HDC);
  721. // NT exports the entry point defined as DWORD GetClipRgn(HDC,HRGN);
  722. // NT will not give out the handle to its internal cliprgn so instead
  723. // makes a copy. Any app uses this private win3.1 entry point will
  724. // have a global region created for it that will go away when the
  725. // app goes away.
  726. GETARGPTR(pFrame, sizeof(GETCLIPRGN16), parg16);
  727. if (CURRENTPTD()->hrgnClip == NULL)
  728. CURRENTPTD()->hrgnClip = CreateRectRgn(0,0,0,0);
  729. GetClipRgn(HDC32(parg16->f1), CURRENTPTD()->hrgnClip);
  730. FREEARGPTR(parg16);
  731. RETURN (GETHRGN16(CURRENTPTD()->hrgnClip));
  732. }