/binding/win32/gdiplusmetafile.d

http://github.com/wilkie/djehuty · D · 425 lines · 224 code · 66 blank · 135 comment · 8 complexity · 904d24c0caba91786e83ee1226f4d60d MD5 · raw file

  1. /*
  2. * gdiplusmetafile.d
  3. *
  4. * This module implements GdiPlusMetaFile.h for D. The original
  5. * copyright info is given below.
  6. *
  7. * Author: Dave Wilkinson
  8. * Originated: November 25th, 2009
  9. *
  10. */
  11. module binding.win32.gdiplusmetafile;
  12. import binding.win32.windef;
  13. import binding.win32.winbase;
  14. import binding.win32.winnt;
  15. import binding.win32.wingdi;
  16. import binding.win32.guiddef;
  17. import binding.win32.gdiplusbase;
  18. import binding.win32.gdiplustypes;
  19. import binding.win32.gdiplusenums;
  20. import binding.win32.gdipluspixelformats;
  21. import binding.win32.gdiplusgpstubs;
  22. import binding.win32.gdiplusmetaheader;
  23. import binding.win32.gdipluspixelformats;
  24. import binding.win32.gdipluscolor;
  25. import binding.win32.gdipluscolormatrix;
  26. import binding.win32.gdiplusflat;
  27. import binding.win32.gdiplusimaging;
  28. import binding.win32.gdiplusbitmap;
  29. import binding.win32.gdiplusimageattributes;
  30. import binding.win32.gdiplusmatrix;
  31. import binding.win32.gdiplusgraphics;
  32. /**************************************************************************\
  33. *
  34. * Copyright (c) 1998-2001, Microsoft Corp. All Rights Reserved.
  35. *
  36. * Module Name:
  37. *
  38. * GdiplusMetafile.h
  39. *
  40. * Abstract:
  41. *
  42. * GDI+ Metafile class
  43. *
  44. \**************************************************************************/
  45. class Metafile : Image {
  46. // Playback a metafile from a HMETAFILE
  47. // If deleteWmf is TRUE, then when the metafile is deleted,
  48. // the hWmf will also be deleted. Otherwise, it won't be.
  49. this(
  50. in HMETAFILE hWmf,
  51. in WmfPlaceableFileHeader * wmfPlaceableFileHeader,
  52. in BOOL deleteWmf = FALSE) {
  53. GpMetafile * metafile = null;
  54. lastResult = GdipCreateMetafileFromWmf(hWmf, deleteWmf,
  55. wmfPlaceableFileHeader,
  56. &metafile);
  57. SetNativeImage(metafile);
  58. }
  59. // Playback a metafile from a HENHMETAFILE
  60. // If deleteEmf is TRUE, then when the metafile is deleted,
  61. // the hEmf will also be deleted. Otherwise, it won't be.
  62. this(in HENHMETAFILE hEmf, in BOOL deleteEmf = FALSE) {
  63. GpMetafile * metafile = null;
  64. lastResult = GdipCreateMetafileFromEmf(hEmf, deleteEmf,
  65. &metafile);
  66. SetNativeImage(metafile);
  67. }
  68. this(in WCHAR* filename) {
  69. GpMetafile * metafile = null;
  70. lastResult = GdipCreateMetafileFromFile(filename,
  71. &metafile);
  72. SetNativeImage(metafile);
  73. }
  74. // Playback a WMF metafile from a file.
  75. this(in WCHAR* filename, in WmfPlaceableFileHeader* wmfPlaceableFileHeader) {
  76. GpMetafile * metafile = null;
  77. lastResult = GdipCreateMetafileFromWmfFile(filename,
  78. wmfPlaceableFileHeader,
  79. &metafile);
  80. SetNativeImage(metafile);
  81. }
  82. //this(in IStream* stream) {
  83. // GpMetafile * metafile = null;
  84. //
  85. // lastResult = GdipCreateMetafileFromStream(stream,
  86. // &metafile);
  87. //
  88. // SetNativeImage(metafile);
  89. //
  90. //}
  91. // Record a metafile to memory.
  92. this(in HDC referenceHdc, in EmfType type = EmfType.EmfTypeEmfPlusDual, in WCHAR* description = null) {
  93. GpMetafile * metafile = null;
  94. lastResult = GdipRecordMetafile(
  95. referenceHdc, type, null, MetafileFrameUnit.MetafileFrameUnitGdi,
  96. description, &metafile);
  97. SetNativeImage(metafile);
  98. }
  99. // Record a metafile to memory.
  100. this(in HDC referenceHdc, in RectF frameRect, in MetafileFrameUnit frameUnit = MetafileFrameUnit.MetafileFrameUnitGdi,
  101. in EmfType type = EmfType.EmfTypeEmfPlusDual, in WCHAR* description = null) {
  102. GpMetafile * metafile = null;
  103. lastResult = GdipRecordMetafile(
  104. referenceHdc, type, &frameRect, frameUnit,
  105. description, &metafile);
  106. SetNativeImage(metafile);
  107. }
  108. // Record a metafile to memory.
  109. this(
  110. in HDC referenceHdc,
  111. in Rect frameRect,
  112. in MetafileFrameUnit frameUnit = MetafileFrameUnit.MetafileFrameUnitGdi,
  113. in EmfType type = EmfType.EmfTypeEmfPlusDual,
  114. in WCHAR * description = null
  115. ) {
  116. GpMetafile * metafile = null;
  117. lastResult = GdipRecordMetafileI(
  118. referenceHdc, type, &frameRect, frameUnit,
  119. description, &metafile);
  120. SetNativeImage(metafile);
  121. }
  122. this(
  123. in WCHAR* fileName,
  124. in HDC referenceHdc,
  125. in EmfType type = EmfType.EmfTypeEmfPlusDual,
  126. in WCHAR * description = null
  127. ) {
  128. GpMetafile * metafile = null;
  129. lastResult = GdipRecordMetafileFileName(fileName,
  130. referenceHdc, type, null, MetafileFrameUnit.MetafileFrameUnitGdi,
  131. description, &metafile);
  132. SetNativeImage(metafile);
  133. }
  134. this(
  135. in WCHAR* fileName,
  136. in HDC referenceHdc,
  137. in RectF frameRect,
  138. in MetafileFrameUnit frameUnit = MetafileFrameUnit.MetafileFrameUnitGdi,
  139. in EmfType type = EmfType.EmfTypeEmfPlusDual,
  140. in WCHAR * description = null
  141. ) {
  142. GpMetafile * metafile = null;
  143. lastResult = GdipRecordMetafileFileName(fileName,
  144. referenceHdc, type, &frameRect, frameUnit,
  145. description, &metafile);
  146. SetNativeImage(metafile);
  147. }
  148. this(
  149. in WCHAR* fileName,
  150. in HDC referenceHdc,
  151. in Rect frameRect,
  152. in MetafileFrameUnit frameUnit = MetafileFrameUnit.MetafileFrameUnitGdi,
  153. in EmfType type = EmfType.EmfTypeEmfPlusDual,
  154. in WCHAR * description = null
  155. ) {
  156. GpMetafile * metafile = null;
  157. lastResult = GdipRecordMetafileFileNameI(fileName,
  158. referenceHdc, type, &frameRect, frameUnit,
  159. description, &metafile);
  160. SetNativeImage(metafile);
  161. }
  162. /*
  163. this(
  164. in IStream * stream,
  165. in HDC referenceHdc,
  166. in EmfType type = EmfType.EmfTypeEmfPlusDual,
  167. in WCHAR * description = null
  168. ) {
  169. GpMetafile * metafile = null;
  170. lastResult = GdipRecordMetafileStream(stream,
  171. referenceHdc, type, null, MetafileFrameUnitGdi,
  172. description, &metafile);
  173. SetNativeImage(metafile);
  174. }
  175. this(
  176. in IStream * stream,
  177. in HDC referenceHdc,
  178. in RectF frameRect,
  179. in MetafileFrameUnit frameUnit = MetafileFrameUnit.MetafileFrameUnitGdi,
  180. in EmfType type = EmfType.EmfTypeEmfPlusDual,
  181. in WCHAR * description = null
  182. ) {
  183. GpMetafile * metafile = null;
  184. lastResult = GdipRecordMetafileStream(stream,
  185. referenceHdc, type, &frameRect, frameUnit,
  186. description, &metafile);
  187. SetNativeImage(metafile);
  188. }
  189. this(
  190. in IStream * stream,
  191. in HDC referenceHdc,
  192. in Rect frameRect,
  193. in MetafileFrameUnit frameUnit = MetafileFrameUnit.MetafileFrameUnitGdi,
  194. in EmfType type = EmfType.EmfTypeEmfPlusDual,
  195. in WCHAR * description = null
  196. ) {
  197. GpMetafile * metafile = null;
  198. lastResult = GdipRecordMetafileStreamI(stream,
  199. referenceHdc, type, &frameRect, frameUnit,
  200. description, &metafile);
  201. SetNativeImage(metafile);
  202. }*/
  203. static Status GetMetafileHeader(in HMETAFILE hWmf, in WmfPlaceableFileHeader* wmfPlaceableFileHeader, MetafileHeader* header) {
  204. return GdipGetMetafileHeaderFromWmf(hWmf, wmfPlaceableFileHeader, header);
  205. }
  206. static Status GetMetafileHeader(in HENHMETAFILE hEmf, MetafileHeader* header) {
  207. return GdipGetMetafileHeaderFromEmf(hEmf, header);
  208. }
  209. static Status GetMetafileHeader(in WCHAR* filename, MetafileHeader* header) {
  210. return GdipGetMetafileHeaderFromFile(filename, header);
  211. }
  212. /*
  213. static Status GetMetafileHeader(
  214. in IStream * stream,
  215. MetafileHeader * header
  216. ) {
  217. return GdipGetMetafileHeaderFromStream(stream, header);
  218. }
  219. */
  220. Status GetMetafileHeader(MetafileHeader* header) {
  221. return SetStatus(GdipGetMetafileHeaderFromMetafile(
  222. cast(GpMetafile *)nativeImage,
  223. header));
  224. }
  225. // Once this method is called, the Metafile object is in an invalid state
  226. // and can no longer be used. It is the responsiblity of the caller to
  227. // invoke DeleteEnhMetaFile to delete this hEmf.
  228. HENHMETAFILE GetHENHMETAFILE() {
  229. HENHMETAFILE hEmf;
  230. SetStatus(GdipGetHemfFromMetafile(
  231. cast(GpMetafile *)nativeImage,
  232. &hEmf));
  233. return hEmf;
  234. }
  235. // Used in conjuction with Graphics::EnumerateMetafile to play an EMF+
  236. // The data must be DWORD aligned if it's an EMF or EMF+. It must be
  237. // WORD aligned if it's a WMF.
  238. Status PlayRecord(in EmfPlusRecordType recordType, in UINT flags, in UINT dataSize, in BYTE* data) {
  239. return SetStatus(GdipPlayMetafileRecord(
  240. cast(GpMetafile *)nativeImage,
  241. recordType,
  242. flags,
  243. dataSize,
  244. data));
  245. }
  246. // If you're using a printer HDC for the metafile, but you want the
  247. // metafile rasterized at screen resolution, then use this API to set
  248. // the rasterization dpi of the metafile to the screen resolution,
  249. // e.g. 96 dpi or 120 dpi.
  250. Status SetDownLevelRasterizationLimit(in UINT metafileRasterizationLimitDpi) {
  251. return SetStatus(
  252. GdipSetMetafileDownLevelRasterizationLimit(
  253. cast(GpMetafile *)nativeImage,
  254. metafileRasterizationLimitDpi));
  255. }
  256. UINT GetDownLevelRasterizationLimit() {
  257. UINT metafileRasterizationLimitDpi = 0;
  258. SetStatus(GdipGetMetafileDownLevelRasterizationLimit(
  259. cast(GpMetafile *)nativeImage,
  260. &metafileRasterizationLimitDpi));
  261. return metafileRasterizationLimitDpi;
  262. }
  263. static UINT EmfToWmfBits(in HENHMETAFILE hemf, in UINT cbData16, LPBYTE pData16, in INT iMapMode = MM_ANISOTROPIC, in INT eFlags = EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault) {
  264. return GdipEmfToWmfBits(
  265. hemf,
  266. cbData16,
  267. pData16,
  268. iMapMode,
  269. eFlags);
  270. }
  271. version(GDIPLUS6) {
  272. Status ConvertToEmfPlus(
  273. in Graphics* refGraphics,
  274. in INT* conversionFailureFlag = null,
  275. in EmfType emfType = EmfType.EmfTypeEmfPlusOnly,
  276. in WCHAR* description = null
  277. ) {
  278. GpMetafile * metafile = null;
  279. GpStatus status = GdipConvertToEmfPlus(
  280. cast(GpGraphics*)refGraphics.nativeGraphics,
  281. cast(GpMetafile *)nativeImage,
  282. conversionFailureFlag,
  283. emfType, description, &metafile);
  284. if (metafile !is null) {
  285. if (status == Status.Ok) {
  286. GdipDisposeImage(nativeImage);
  287. SetNativeImage(metafile);
  288. }
  289. else {
  290. GdipDisposeImage(metafile);
  291. }
  292. }
  293. return status;
  294. }
  295. Status ConvertToEmfPlus(
  296. in Graphics* refGraphics,
  297. in WCHAR* filename,
  298. in INT* conversionFailureFlag = null,
  299. in EmfType emfType = EmfType.EmfTypeEmfPlusOnly,
  300. in WCHAR* description = null
  301. ) {
  302. GpMetafile * metafile = null;
  303. GpStatus status = GdipConvertToEmfPlusToFile(
  304. cast(GpGraphics*)refGraphics.nativeGraphics,
  305. cast(GpMetafile *)nativeImage,
  306. conversionFailureFlag,
  307. filename, emfType, description, &metafile);
  308. if (metafile !is null) {
  309. if (status == Status.Ok) {
  310. GdipDisposeImage(nativeImage);
  311. SetNativeImage(metafile);
  312. }
  313. else {
  314. GdipDisposeImage(metafile);
  315. }
  316. }
  317. return status;
  318. }
  319. }
  320. /* Status ConvertToEmfPlus(
  321. in Graphics* refGraphics,
  322. in IStream* stream,
  323. in INT* conversionFailureFlag = null,
  324. in EmfType emfType = EmfType.EmfTypeEmfPlusOnly,
  325. in WCHAR* description = null
  326. ) {
  327. GpMetafile * metafile = null;
  328. GpStatus status = GdipConvertToEmfPlusToStream(
  329. cast(GpGraphics*)refGraphics.nativeGraphics,
  330. cast(GpMetafile *)nativeImage,
  331. conversionFailureFlag,
  332. stream, emfType, description, &metafile);
  333. if (metafile != null) {
  334. if (status == Status.Ok) {
  335. GdipDisposeImage(nativeImage);
  336. SetNativeImage(metafile);
  337. }
  338. else {
  339. GdipDisposeImage(metafile);
  340. }
  341. }
  342. return status;
  343. }
  344. */
  345. protected:
  346. this() {
  347. SetNativeImage(null);
  348. lastResult = Status.Ok;
  349. }
  350. }