* System.Drawing/Image.cs: On win32, when cloning images initialized from
[mono.git] / mcs / class / System.Drawing / System.Drawing.Imaging / MetafileHeader.cs
index a248d74cc3997594c4f90d5a0f5ee35cf3cb72a9..242d2c3342c0be5510063074f5ad80c6e22fc9b3 100644 (file)
@@ -1,14 +1,12 @@
 //
 // System.Drawing.Imaging.MetafileHeader.cs
 //
-// (C) 2002 Ximian, Inc.  http://www.ximian.com
 // Author: Everaldo Canuto
 // eMail: everaldo.canuto@bol.com.br
 // Dennis Hayes (dennish@raytek.com)
 //
-
-//
-// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+// (C) 2002 Ximian, Inc.  http://www.ximian.com
+// Copyright (C) 2004, 2006 Novell, Inc (http://www.novell.com)
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
-using System;
+
+using System.Drawing.Drawing2D;
 using System.Runtime.InteropServices;
 
 namespace System.Drawing.Imaging {
 
-       [MonoTODO]
+       [StructLayout(LayoutKind.Sequential, Pack=2)]
+       struct EnhMetafileHeader {
+               public int              type;
+               public int              size;
+               public Rectangle        bounds;
+               public Rectangle        frame;
+               public int              signature;
+               public int              version;
+               public int              bytes;
+               public int              records;
+               public short            handles;
+               public short            reserved;
+               public int              description;
+               public int              off_description;
+               public int              palette_entires;
+               public Size             device;
+               public Size             millimeters;
+       }
+
+       // hack: keep public type as Sequential while making it possible to get the required union
+       [StructLayout(LayoutKind.Explicit)]
+       struct MonoMetafileHeader {
+               [FieldOffset (0)]
+               public MetafileType     type;
+               [FieldOffset (4)]
+               public int              size;
+               [FieldOffset (8)]
+               public int              version;
+               [FieldOffset (12)]
+               public int              emf_plus_flags;
+               [FieldOffset (16)]
+               public float            dpi_x;
+               [FieldOffset (20)]
+               public float            dpi_y;
+               [FieldOffset (24)]
+               public int              x;
+               [FieldOffset (28)]
+               public int              y;
+               [FieldOffset (32)]
+               public int              width;
+               [FieldOffset (36)]
+               public int              height;
+               [FieldOffset (40)]
+               public WmfMetaHeader    wmf_header;
+               [FieldOffset (40)]
+               public EnhMetafileHeader emf_header;
+               [FieldOffset (128)]
+               public int              emfplus_header_size;
+               [FieldOffset (132)]
+               public int              logical_dpi_x;
+               [FieldOffset (136)]
+               public int              logical_dpi_y;
+       }
+
+       [MonoTODO ("Metafiles, both WMF and EMF formats, aren't supported.")]
 #if !TARGET_JVM
        [StructLayout(LayoutKind.Sequential)]
 #endif
-       public sealed class MetafileHeader 
-       {
+       public sealed class MetafileHeader {
+
+               private MonoMetafileHeader header;
                
                //constructor
-               internal MetafileHeader()
+
+               internal MetafileHeader (IntPtr henhmetafile)
                {
-                       //Nothing to be done here
+                       Marshal.PtrToStructure (henhmetafile, this);
                }
 
                // methods
-               [MonoTODO]
-               public bool IsDisplay() {
-                       throw new NotImplementedException ();
+
+               [MonoTODO ("always returns false")]
+               public bool IsDisplay ()
+               {
+                       return false;
                }
 
-               [MonoTODO]
-               public bool IsEmf() {
-                       throw new NotImplementedException ();
+               public bool IsEmf ()
+               {
+                       return (Type == MetafileType.Emf);
                }
 
-               [MonoTODO]
-               public bool IsEmfOrEmfPlus() {
-                       throw new NotImplementedException ();
+               public bool IsEmfOrEmfPlus ()
+               {
+                       return (Type >= MetafileType.Emf);
                }
 
-               [MonoTODO]
-               public bool IsEmfPlus() {
-                       throw new NotImplementedException ();
+               public bool IsEmfPlus ()
+               {
+                       return (Type >= MetafileType.EmfPlusOnly);
                }
 
-               [MonoTODO]
-               public bool IsEmfPlusDual() {
-                       throw new NotImplementedException ();
+               public bool IsEmfPlusDual ()
+               {
+                       return (Type == MetafileType.EmfPlusDual);
                }
 
-               [MonoTODO]
-               public bool IsEmfPlusOnly() {
-                       throw new NotImplementedException ();
+               public bool IsEmfPlusOnly ()
+               {
+                       return (Type == MetafileType.EmfPlusOnly);
                }
 
-               [MonoTODO]
-               public bool IsWmf() {
-                       throw new NotImplementedException ();
+               public bool IsWmf ()
+               {
+                       return (Type <= MetafileType.WmfPlaceable);
                }
 
-               [MonoTODO]
-               public bool IsWmfPlaceable() {
-                       throw new NotImplementedException ();
+               public bool IsWmfPlaceable ()
+               {
+                       return (Type == MetafileType.WmfPlaceable);
                }
 
                // properties
-               [MonoTODO]
+
                public Rectangle Bounds {
-                       get { throw new NotImplementedException (); }
+                       get { return new Rectangle (header.x, header.y, header.width, header.height); }
                }
 
-               [MonoTODO]
                public float DpiX {
-                       get { throw new NotImplementedException (); }
+                       get { return header.dpi_x; }
                }
                
-               [MonoTODO]
                public float DpiY {
-                       get { throw new NotImplementedException (); }
+                       get { return header.dpi_y; }
                }
                
-               [MonoTODO]
                public int EmfPlusHeaderSize {
-                       get { throw new NotImplementedException (); }
+                       get { return header.emfplus_header_size; }
                }
 
-               [MonoTODO]
                public int LogicalDpiX {
-                       get { throw new NotImplementedException (); }
+                       get { return header.logical_dpi_x; }
                }
                
-               [MonoTODO]
                public int LogicalDpiY {
-                       get { throw new NotImplementedException (); }
+                       get { return header.logical_dpi_y; }
                }
-               
-               [MonoTODO]
+
                public int MetafileSize {
-                       get { throw new NotImplementedException (); }
+                       get { return header.size; }
                }
 
-               [MonoTODO]
                public MetafileType Type {
-                       get { throw new NotImplementedException (); }
+                       get { return header.type; }
                }
 
-               [MonoTODO]
                public int Version {
-                       get { throw new NotImplementedException (); }
+                       get { return header.version; }
                }
-               
-               [MonoTODO]
+
+               // note: this always returns a new instance (where we can change
+               // properties even if they don't seems to affect anything)
                public MetaHeader WmfHeader {
-                       get { throw new NotImplementedException (); }
+                       get {
+                               if (IsWmf ())
+                                        return new MetaHeader (header.wmf_header);
+                               throw new ArgumentException ("WmfHeader only available on WMF files.");
+                       }
                }
-
        }
-
 }