Merge branch 'master'

[mono.git] / mcs / class / System.Drawing / System.Drawing.Imaging / MetafileHeader.cs

diff --git a/mcs/class/System.Drawing/System.Drawing.Imaging/MetafileHeader.cs b/mcs/class/System.Drawing/System.Drawing.Imaging/MetafileHeader.cs
index 0361eb3989e25717c678165bf3f72d84889df0f7..bd73b2d2bc1535d5da26029d121dfb7626e7b704 100644 (file)
--- a/mcs/class/System.Drawing/System.Drawing.Imaging/MetafileHeader.cs
+++ b/mcs/class/System.Drawing/System.Drawing.Imaging/MetafileHeader.cs
@@ -28,104 +28,167 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
+using System.Drawing.Drawing2D;
 using System.Runtime.InteropServices;
 
 namespace System.Drawing.Imaging {
 
+       [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 {
+
+               private MonoMetafileHeader header;
                
                //constructor
-               internal MetafileHeader()
+
+               internal MetafileHeader (IntPtr henhmetafile)
                {
-                       //Nothing to be done here
+                       Marshal.PtrToStructure (henhmetafile, this);
                }
 
                // methods
 
+               [MonoTODO ("always returns false")]
                public bool IsDisplay ()
                {
-                       throw new NotImplementedException ();
+                       return false;
                }
 
                public bool IsEmf ()
                {
-                       throw new NotImplementedException ();
+                       return (Type == MetafileType.Emf);
                }
 
                public bool IsEmfOrEmfPlus ()
                {
-                       throw new NotImplementedException ();
+                       return (Type >= MetafileType.Emf);
                }
 
                public bool IsEmfPlus ()
                {
-                       throw new NotImplementedException ();
+                       return (Type >= MetafileType.EmfPlusOnly);
                }
 
                public bool IsEmfPlusDual ()
                {
-                       throw new NotImplementedException ();
+                       return (Type == MetafileType.EmfPlusDual);
                }
 
                public bool IsEmfPlusOnly ()
                {
-                       throw new NotImplementedException ();
+                       return (Type == MetafileType.EmfPlusOnly);
                }
 
                public bool IsWmf ()
                {
-                       throw new NotImplementedException ();
+                       return (Type <= MetafileType.WmfPlaceable);
                }
 
                public bool IsWmfPlaceable ()
                {
-                       throw new NotImplementedException ();
+                       return (Type == MetafileType.WmfPlaceable);
                }
 
                // properties
 
                public Rectangle Bounds {
-                       get { throw new NotImplementedException (); }
+                       get { return new Rectangle (header.x, header.y, header.width, header.height); }
                }
 
                public float DpiX {
-                       get { throw new NotImplementedException (); }
+                       get { return header.dpi_x; }
                }
                
                public float DpiY {
-                       get { throw new NotImplementedException (); }
+                       get { return header.dpi_y; }
                }
                
                public int EmfPlusHeaderSize {
-                       get { throw new NotImplementedException (); }
+                       get { return header.emfplus_header_size; }
                }
 
                public int LogicalDpiX {
-                       get { throw new NotImplementedException (); }
+                       get { return header.logical_dpi_x; }
                }
                
                public int LogicalDpiY {
-                       get { throw new NotImplementedException (); }
+                       get { return header.logical_dpi_y; }
                }
-               
+
                public int MetafileSize {
-                       get { throw new NotImplementedException (); }
+                       get { return header.size; }
                }
 
                public MetafileType Type {
-                       get { throw new NotImplementedException (); }
+                       get { return header.type; }
                }
 
                public int Version {
-                       get { throw new NotImplementedException (); }
+                       get { return header.version; }
                }
-               
+
+               // 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.");
+                       }
                }
        }
 }