private static void DrawTree(TreeNode treeNode, string file)
        {
            using (Metafile mf = new Metafile(file, Graphics.FromHwnd(IntPtr.Zero).GetHdc(), EmfType.EmfOnly))
            {
                using (Graphics graphics = Graphics.FromImage(mf))
                {
                    graphics.PageUnit = GraphicsUnit.Point;

                    Font labelFont = new Font("SimSun", 9.0f, FontStyle.Regular, GraphicsUnit.Point);
                    DrawTreeContext context = new DrawTreeContext()
                    {
                        Graphics = graphics,
                        BorderPen = new Pen(Color.Black, 0.75f),
                        ConnectorPen = new Pen(Color.Black, 0.5f),
                        LabelBrush = Brushes.Black,
                        LabelFont = labelFont,
                        LabelHeight = labelFont.Size,
                        NodeHorizontalSep = 9.0,
                        NodeVerticalSep = 24.0,
                        NodeHorizontalPadding = 3.75,
                        NodeVerticalPadding = 3.75,
                        PreferCjk = true
                    };

                    treeNode.DrawTree(context, new PointD(treeNode.Layout(context).Pivot, 0.0));
                }
            }
        }

		/// <summary>
		/// Saves the specified <see cref="Metafile"/> at the specified path.
		/// </summary>
		/// 
		/// <exception cref="ArgumentNullException">
		/// <para>
		///		<paramref name="path"/> is <see langword="null"/>.
		/// </para>
		/// -or-
		/// <para>
		///		<paramref name="path"/> is an empty string.
		/// </para>
		/// -or-
		/// <para>
		///		<paramref name="metafileToSave"/> is <see langword="null"/>.
		/// </para>
		/// </exception>
		public static void Save(string path, Metafile metafileToSave)
		{
			if (string.IsNullOrEmpty(path))
			{
				throw new ArgumentNullException("path");
			}

			if (metafileToSave == null)
			{
				throw new ArgumentNullException("metafileToSave");
			}

			FileStream stream = null;

			try
			{
				stream = new FileStream(path, FileMode.Create);
				Save(stream, metafileToSave);
			}
			catch
			{
				throw;
			}
			finally
			{
				if (stream != null)
				{
					stream.Flush();
					stream.Close();
				}
			}
		}

            protected override void OnPrintPage(PrintPageEventArgs e)
            {
                base.OnPrintPage(e);

                Stream pageToPrint = m_pages[m_currentPage];
                pageToPrint.Position = 0;

                // Load each page into a Metafile to draw it.
                using (Metafile pageMetaFile = new Metafile(pageToPrint))
                {
                    Rectangle adjustedRect = new Rectangle(
                            e.PageBounds.Left - (int)e.PageSettings.HardMarginX,
                            e.PageBounds.Top - (int)e.PageSettings.HardMarginY,
                            e.PageBounds.Width,
                            e.PageBounds.Height);

                    // Draw a white background for the report
                    e.Graphics.FillRectangle(Brushes.White, adjustedRect);

                    // Draw the report content
                    e.Graphics.DrawImage(pageMetaFile, adjustedRect);

                    // Prepare for next page.  Make sure we haven't hit the end.
                    m_currentPage++;
                    e.HasMorePages = m_currentPage < m_pages.Count;
                }
            }

        /// <summary>
        /// Create image metafile constructor
        /// </summary>
        /// <param name="Width">Image width in pixels.</param>
        /// <param name="Height">Image height in pixels.</param>
        public CreateMetafile(
			Int32	Width,
			Int32	Height
			)
        {
            using (MemoryStream Stream = new MemoryStream())
            {
            using (Graphics MemoryGraphics = Graphics.FromHwndInternal(IntPtr.Zero))
                {
                IntPtr deviceContextHandle = MemoryGraphics.GetHdc();
                Metafile = new Metafile(Stream, deviceContextHandle, new RectangleF(0, 0, Width, Height), MetafileFrameUnit.Pixel, EmfType.EmfPlusOnly);
                MemoryGraphics.ReleaseHdc();
                }
            }

            Graphics = Graphics.FromImage(Metafile);

            // Set everything to high quality
            Graphics.SmoothingMode = SmoothingMode.HighQuality;
            Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            Graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
            Graphics.CompositingQuality = CompositingQuality.HighQuality;
             		Graphics.PageUnit = GraphicsUnit.Pixel;
            return;
        }

 /// <summary>
 /// Copies the given <see cref="T:System.Drawing.Imaging.MetaFile" /> to the clipboard.
 /// The given <see cref="T:System.Drawing.Imaging.MetaFile" /> is set to an invalid state inside this function.
 /// </summary>
 public static bool PutEnhMetafileOnClipboard(IntPtr hWnd, Metafile metafile, bool clearClipboard)
 {
     if (metafile == null) throw new ArgumentNullException("metafile");
     bool bResult = false;
     IntPtr hEMF, hEMF2;
     hEMF = metafile.GetHenhmetafile(); // invalidates mf
     if (!hEMF.Equals(IntPtr.Zero)) {
         try {
             hEMF2 = CopyEnhMetaFile(hEMF, null);
             if (!hEMF2.Equals(IntPtr.Zero)) {
                 if (OpenClipboard(hWnd)) {
                     try {
                         if (clearClipboard) {
                             if (!EmptyClipboard())
                                 return false;
                         }
                         IntPtr hRes = SetClipboardData(14 /*CF_ENHMETAFILE*/, hEMF2);
                         bResult = hRes.Equals(hEMF2);
                     } finally {
                         CloseClipboard();
                     }
                 }
             }
         } finally {
             DeleteEnhMetaFile(hEMF);
         }
     }
     return bResult;
 }

        public override Graphics OnStartPage(PrintDocument document, PrintPageEventArgs e)
        {
            Bitmap bmp = new Bitmap(1, 1);

            Graphics bmpg = Graphics.FromImage(bmp);
            IntPtr hdc = bmpg.GetHdc();
            ms = new MemoryStream();
            Metafile meta = new Metafile(ms, hdc, EmfType.EmfPlusDual);
            bmpg.ReleaseHdc(hdc);

            this.pic.Image = meta;

            Graphics g = Graphics.FromImage(meta);

            PaperSize size = e.PageSettings.PaperSize;
            int height = size.Height * dpi / 100;
            int width = size.Width * dpi / 100;

            if (e.PageSettings.Landscape)
            {
                g.FillRectangle(Brushes.White, 0, 0, height, width);
                g.SetClip(new Rectangle(0, 0, height - 16, width - 16));
            }
            else
            {
                g.FillRectangle(Brushes.White, 0, 0, width, height);
                g.SetClip(new Rectangle(0, 0, width - 16, height - 16));
            }

            return g;
        }

        public void ExportImage(string filename)
        {
            switch (Path.GetExtension(filename).ToLower())
              {
            case ".png":
              Bitmap bmp = new Bitmap(ClientRectangle.Width, ClientRectangle.Height);
              using (Graphics g = Graphics.FromImage(bmp))
              {
            _chart.Draw(g);
            bmp.Save(filename);
              }
              break;

            case ".emf":
              using (Graphics g = this.CreateGraphics())
              {
            IntPtr hdc = g.GetHdc();

            Metafile mf = new Metafile(filename, hdc);

            using (Graphics mg = Graphics.FromImage(mf))
            {
              using (mf)
              {
                _chart.Draw(mg);
              }
            }

            g.ReleaseHdc(hdc);
              }
              break;
              }
        }

 public void ProcessEMF(byte[] emf)
 {
     try
     {
         _ms = new MemoryStream(emf);
         _mf = new Metafile(_ms);
         _bm = new Bitmap(1, 1);
         g = Graphics.FromImage(_bm);
         //XScale = Width / _mf.Width;
         //YScale = Height/ _mf.Height;
         m_delegate = new Graphics.EnumerateMetafileProc(MetafileCallback);
         g.EnumerateMetafile(_mf, new Point(0, 0), m_delegate);
     }
     finally
     {
         if (g != null)
             g.Dispose();
         if (_bm != null)
             _bm.Dispose();
         if (_ms != null)
         {
             _ms.Close();
             _ms.Dispose();
         }
     }
 }

        public static Metafile Convert(
            string htmlSnippet, 
            float leftBorder = 0, 
            float topBorder = 0, 
            float rightBorder = 0, 
            float bottomBorder = 0)
        {
            Metafile image;
            IntPtr dib;
            IntPtr memoryHdc = Win32Utils.CreateMemoryHdc(IntPtr.Zero, 1, 1, out dib);
            try
            {
                image = new Metafile(memoryHdc, EmfType.EmfPlusDual, "..");

                using (Graphics g = Graphics.FromImage(image))
                {
                    SizeF size = HtmlRender.Measure(g, htmlSnippet);
                    
                    g.FillRectangle(
                        Brushes.White, 
                        leftBorder * -1, 
                        topBorder * -1, 
                        size.Width + leftBorder + rightBorder, 
                        size.Height + topBorder + bottomBorder);

                    SizeF sizeF = HtmlRender.Render(g, htmlSnippet);
                }
            }
            finally
            {
                Win32Utils.ReleaseMemoryHdc(memoryHdc, dib);
            }
            return image;
        }

        private static Image GetImageFromParams(object pict, IntPtr handle, int pictype, IntPtr paletteHandle, int width,
		                                        int height)
        {
            switch (pictype)
            {
                case -1:
                    return null;

                case 0:
                    return null;

                case 1:
                    return Image.FromHbitmap(handle, paletteHandle);

                case 2:
                    {
                        var wmfHeader = new WmfPlaceableFileHeader();
                        wmfHeader.BboxRight = (short) width;
                        wmfHeader.BboxBottom = (short) height;
                        var metafile = new Metafile(handle, wmfHeader, false);
                        return (Image) RuntimeHelpers.GetObjectValue(metafile.Clone());
                    }
                case 4:
                    {
                        var metafile2 = new Metafile(handle, false);
                        return (Image) RuntimeHelpers.GetObjectValue(metafile2.Clone());
                    }
            }
            throw new Exception("AXUnknownImage");
        }

        private static void SaveClipboardEmf(Stream stream, ImageFormat format)
        {
            OpenClipboard();

            try
            {
                if (!IsClipboardFormatAvailable(CF_ENHMETAFILE))
                {
                    Failed("No enhanced metafile data available.");
                }

                IntPtr ptr = GetClipboardData(CF_ENHMETAFILE);

                if (ptr == IntPtr.Zero)
                {
                    Failed("Unable to retrieve data from clipboard even through Clipboard previously indicated data exists.");
                }

                var metafile = new Metafile(ptr, true);
                metafile.Save(stream, format);
            }
            finally
            {
                // "An application should call the CloseClipboard function after every successful call to OpenClipboard."
                //   -- http://msdn.microsoft.com/en-us/library/windows/desktop/ms649048(v=vs.85).aspx
                CloseClipboard();
            }
        }

        protected override Image DrawSvg(SvgDocument svgDoc)
        {
            // GDI+
            Metafile metafile;
            using (var stream = new MemoryStream())
            using (var img = new Bitmap((int)svgDoc.Width.Value, (int)svgDoc.Height.Value)) // Not necessary if you use Control.CreateGraphics().
            using (Graphics ctrlGraphics = Graphics.FromImage(img)) // Control.CreateGraphics()
            {
                IntPtr handle = ctrlGraphics.GetHdc();

                var rect = new RectangleF(0, 0, svgDoc.Width, svgDoc.Height);
                metafile = new Metafile(stream,
                    handle,
                    rect,
                    MetafileFrameUnit.Pixel,
                    EmfType.EmfPlusOnly);

                using (Graphics ig = Graphics.FromImage(metafile))
                {
                    svgDoc.Draw(ig);
                }

                ctrlGraphics.ReleaseHdc(handle);
            }

            return metafile;
        }

        // Загрузка рисунка из файла
        private void LoadWMFFile(String name)
        {
            // Создание рисунка из файла
            this.wmfImage = new Metafile(name);

            // Вызов метода перерисовки формы
            this.Invalidate();
        }

        private void PrintPage(object sender, PrintPageEventArgs ev)
        {
            Metafile pageImage = new Metafile(m_streams[m_currentPageIndex]);
            ev.Graphics.DrawImage(pageImage, ev.PageBounds);

            m_currentPageIndex++;
            ev.HasMorePages = (m_currentPageIndex < m_streams.Count);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="bitmap"></param>
        /// <param name="shapes"></param>
        /// <param name="properties"></param>
        /// <param name="ic"></param>
        /// <returns></returns>
        public MemoryStream MakeMetafileStream(
            Bitmap bitmap,
            IEnumerable<BaseShape> shapes,
            ImmutableArray<ShapeProperty> properties,
            IImageCache ic)
        {
            var g = default(Graphics);
            var mf = default(Metafile);
            var ms = new MemoryStream();

            try
            {
                using (g = Graphics.FromImage(bitmap))
                {
                    var hdc = g.GetHdc();
                    mf = new Metafile(ms, hdc);
                    g.ReleaseHdc(hdc);
                }

                using (g = Graphics.FromImage(mf))
                {
                    var r = new EmfRenderer(72.0 / 96.0);
                    r.State.ImageCache = ic;

                    g.SmoothingMode = SmoothingMode.HighQuality;
                    g.PixelOffsetMode = PixelOffsetMode.HighQuality;
                    g.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
                    g.CompositingQuality = CompositingQuality.HighQuality;
                    g.InterpolationMode = InterpolationMode.HighQualityBicubic;

                    g.PageUnit = GraphicsUnit.Display;

                    if (shapes != null)
                    {
                        foreach (var shape in shapes)
                        {
                            shape.Draw(g, r, 0, 0, properties, null);
                        }
                    }

                    r.ClearCache(isZooming: false);
                }
            }
            finally
            {
                if (g != null)
                {
                    g.Dispose();
                }

                if (mf != null)
                {
                    mf.Dispose();
                }
            }
            return ms;
        }

		/*
		 * MetafileToString
		 */

		/// <summary>
		/// </summary>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="metafileToConvert"/> is <see langword="null"/>.
		/// </exception>
		public static string MetafileToString(Metafile metafileToConvert)
		{
			if (metafileToConvert == null)
			{
				throw new ArgumentNullException("metafileToConvert");
			}

			byte[] buffer = NuGenMetafileConverter.MetafileToBytes(metafileToConvert);
			return Convert.ToBase64String(buffer);
		}

 public EMFRenderer(int width, int height)
 {
     Bitmap bmp = new Bitmap(width, height);
     m_graphics = Graphics.FromImage(bmp);
     m_stream = new MemoryStream();
     m_metafile = new Metafile(m_graphics.GetHdc(), new RectangleF(0, 0, width, height), MetafileFrameUnit.Pixel);
     m_graphics.ReleaseHdc();
     m_graphics.Dispose();
     bmp.Dispose();
     m_graphics = Graphics.FromImage(m_metafile);
 }

 public override void skolaUppdaterad()
 {
     if ( _mf!=null )
         _mf.Dispose();
     string strMF = Global.Skola.HomePathCombine( "!fotoorder.emf" );
     if ( System.IO.File.Exists(strMF) )
         _mf = new Metafile( strMF );
     else
         _mf = null;
     resize2(this.ClientSize);
     this.Invalidate();
 }

		private void CreateInternalMetafile(EmfType type)
		{
			//Create a temporary bitmap to get an HDC
			Graphics graphics = Component.Instance.CreateGraphics();
			IntPtr hDC = graphics.GetHdc();

			//Create metafile based on type and get graphics handle
			mMetafile = new System.Drawing.Imaging.Metafile(hDC, type);
			graphics.ReleaseHdc(hDC);

			graphics.Dispose();
		}

        public static void SaveMetafile(Metafile mf, Stream stream)
        {
            IntPtr henh = mf.GetHenhmetafile ();
            int size = GetEnhMetaFileBits (henh, 0, null);

            byte[] buffer = new byte[size];

            if (GetEnhMetaFileBits (henh, size, buffer) <= 0)
                throw new SystemException ("GetEnhMetaFileBits");

            stream.Write (buffer, 0, buffer.Length);
            stream.Flush ();
        }