/// <summary>
 /// Initializes the BitmapBuffer from a System.Drawing.Bitmap
 /// </summary>
 public BitmapBuffer(sd.Bitmap bitmap, BitmapLoadOptions options)
 {
     if (options.AllowWrap && bitmap.PixelFormat == PixelFormat.Format32bppArgb)
     {
         Width = bitmap.Width;
         Height = bitmap.Height;
         WrappedBitmap = bitmap;
     }
     else LoadInternal(null, bitmap, options);
 }

 /// <summary>
 /// Get the W3C standard MIME type for this image
 /// </summary>
 /// <param name="image">Image to parse</param>
 /// <returns>Image MIME type or 'image/unknown' if not found</returns>
 public static string GetMIMEType(SysDrawing.Image image)
 {
     // [Citation("200803142256", AcquiredDate = "2008-03-14", Author = "Chris Hynes", Source = "http://chrishynes.net/blog/archive/2008/01/17/Get-the-MIME-type-of-a-System.Drawing-Image.aspx", SourceDate = "2008-01-17")]
     foreach (ImageCodecInfo codec in ImageCodecInfo.GetImageDecoders())
     {
         if (codec.FormatID == image.RawFormat.Guid)
             return codec.MimeType;
     }
     return Mime.Map[""].MediaType;
 }

        /// <summary>
        /// Constructs a system tray icon
        /// </summary>
        /// <param name="mainForm"></param>
        /// <param name="icon"></param>
        public SysTrayIcon(MainForm mainForm, Drawing.Icon icon)
        {
            this.mainForm = mainForm;

            this.notify = new WinForms.NotifyIcon();
            this.notify.Text = "NBM";
            this.notify.Icon = icon;
            this.notify.Click += new EventHandler(OnSysTrayClick);
            this.notify.ContextMenu = new SysTrayContextMenu(mainForm);
            this.notify.Visible = true;
        }

        private static Drawing.Icon DrawIcon(Drawing.Brush fillBrush, string message, int dimension)
        {
            Drawing.Icon oIcon = null;

            Drawing.Bitmap bm = new Drawing.Bitmap(dimension, dimension);
            Drawing.Graphics g = Drawing.Graphics.FromImage((Drawing.Image)bm);
            g.SmoothingMode = Drawing2D.SmoothingMode.AntiAlias;
            Drawing.Font oFont = new Drawing.Font("Arial", 30, Drawing.FontStyle.Bold, Drawing.GraphicsUnit.Pixel);
            g.FillRectangle(fillBrush, new Drawing.Rectangle(0, 0, bm.Width, bm.Height));
            g.DrawString(message, oFont, new Drawing.SolidBrush(Drawing.Color.Black), 2, 0);
            oIcon = Drawing.Icon.FromHandle(bm.GetHicon());
            oFont.Dispose();
            g.Dispose();
            bm.Dispose();
            return oIcon;
        }

 /**
   <summary>Creates a new form within the specified document context.</summary>
   <param name="context">Document where to place this form.</param>
   <param name="size">Form size.</param>
 */
 public FormXObject(
     Document context,
     drawing::SizeF size
     )
     : this(context, new drawing::RectangleF(new drawing::PointF(0, 0), size))
 {
 }

 public RenderableText(string pmText, Sdx.Font pmFont, Point pmPosition, float pmWrapSize)
 {
     text=	pmText;
     font=	pmFont;
     position=	pmPosition;
     wrapSize=	pmWrapSize;
 }

        public void CleanUp(D2D1.RenderTarget target, GDI.Graphics g, Map map)
        {
            target.EndDraw();
            using (var sc = TakeScreenshotGdi(map.Size))
                g.DrawImage(sc, new GDI.Point(0, 0));
            
            target.Dispose();

            //Monitor.Exit(_syncRoot);
        }

        private static void Aiguille2(Graphics g, double pc, D.Brush b, double r, float pw, double x0, double y0)
        {
            double x1, y1, x2, y2;

            double a = GetAFromPc(pc);

            GetXY2(a, r, x0, y0, out x1, out y1);
            GetXY2(a+Math.PI, r/5.0, x0, y0, out x2, out y2);

            g.DrawLine(new D.Pen(b, pw), (float)x1, (float)y1, (float)x2, (float)y2);
        }

        public static Texture2D BitmapToTexture(GraphicsDevice device, Gdi.Bitmap bitmap)
        {
            MemoryStream ms = new MemoryStream();
            bitmap.Save(ms, ImageFormat.Png); // Save the bitmap to memory
            bitmap.Dispose(); // Dispose the bitmap object

            Texture2D tex = Texture2D.FromStream(device, ms); // Load the texture from the bitmap in memory
            ms.Close(); // Close the memorystream
            ms.Dispose(); // Dispose the memorystream
            return tex; // return the texture
        }

 public Gdi.RectangleF ToScaledRectangleF(Gdi.Size screenBounds, Vector3D position, double radius)
 {
     var size = (float)(2 * radius);
     return new Gdi.RectangleF
     {
         X = (float)(position.X * screenBounds.Width - radius),
         Y = (float)(position.Y * screenBounds.Height - radius),
         Width = size,
         Height = size
     };
 }

 private Dictionary<JointType, Vector3D> CalculateBoxJoints(Gdi.RectangleF skeletonBox)
 {
     return base.SkeletonComponent.CurrentSkeleton.Select(kvp =>
             Tuple.Create(
                 kvp.Key,
                 new Vector3D(
                     kvp.Value.LocationScreenPercent.X * skeletonBox.Width + skeletonBox.X,
                     (1 - kvp.Value.LocationScreenPercent.Y) * skeletonBox.Height + skeletonBox.Y, //y is flipped
                     0)))
         .ToDictionary(tuple => tuple.Item1, tuple => tuple.Item2);
 }

		public static NSImage Resize(this NSImage image, sd.Size newsize, ImageInterpolation interpolation = ImageInterpolation.Default)
		{
			var newimage = new NSImage(newsize);
			var newrep = new NSBitmapImageRep(IntPtr.Zero, newsize.Width, newsize.Height, 8, 4, true, false, NSColorSpace.DeviceRGB, 4 * newsize.Width, 32);
			newimage.AddRepresentation(newrep);

			var graphics = NSGraphicsContext.FromBitmap(newrep);
			NSGraphicsContext.GlobalSaveGraphicsState();
			NSGraphicsContext.CurrentContext = graphics;
			graphics.GraphicsPort.InterpolationQuality = interpolation.ToCG();
			image.DrawInRect(new sd.RectangleF(sd.PointF.Empty, newimage.Size), new sd.RectangleF(sd.PointF.Empty, image.Size), NSCompositingOperation.SourceOver, 1f);
			NSGraphicsContext.GlobalRestoreGraphicsState();
			return newimage;
		}

        public byte[] EncodeGdi(SD.Bitmap image, float bitrate = WsqCodec.Constants.DefaultBitrate, bool autoConvertToGrayscale = true)
        {
            if (image == null) throw new ArgumentNullException("image");

            RawImageData data = null;
            if (autoConvertToGrayscale)
            {
                using (var source = Conversions.To8bppBitmap(image))
                    data = Conversions.GdiImageToImageInfo(source);
            }
            else data = Conversions.GdiImageToImageInfo(image);

            return WsqCodec.Encode(data, bitrate, Comment);
        }

 /// <summary>
 /// Function to start showing video
 /// </summary>
 /// <param name="videoHandle">Video handle</param>
 /// <param name="videoRegion">Region where to show video</param>
 /// <param name="videoHorizontalResolution">Video horizontal resolution</param>
 /// <param name="videoVerticalResolution">Video vertical resolution</param>
 public void StartVideo(IntPtr videoHandle, SD.Rectangle videoRegion, int videoHorizontalResolution, int videoVerticalResolution)
 {
     //// Creates instance of Web cam class of DirectShow
     this.webCam = new Webcam(videoHandle);
     var selectedCamera = this.SelectCamera();
     if (selectedCamera >= 0)
     {
         var deviceName = this.webCam.StartVideo(videoHandle, videoRegion, videoHorizontalResolution, videoVerticalResolution, selectedCamera);
         CameraStatus.Status = string.IsNullOrEmpty(deviceName) ? CameraAvailability.Busy : CameraAvailability.Available;
     }
     else
     {
         CameraStatus.Status = CameraAvailability.NotAvailable;
     }
 }

        public Texture(Sdx.Bitmap bmp)
        {
            // Variables
            Sdx.Imaging.BitmapData	bmpdata=	bmp.LockBits(new Sdx.Rectangle(0, 0, bmp.Width, bmp.Height), Sdx.Imaging.ImageLockMode.ReadOnly, Sdx.Imaging.PixelFormat.Format32bppArgb);
            int	tid=	GL.GenTexture();

            GL.BindTexture(TextureTarget.Texture2D, tid);
            GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, bmp.Width, bmp.Height, 0, PixelFormat.Bgra, PixelType.UnsignedByte, bmpdata.Scan0);
            bmp.UnlockBits(bmpdata);

            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int) TextureMinFilter.Linear);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int) TextureMagFilter.Linear);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int) TextureWrapMode.Repeat);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int) TextureWrapMode.Repeat);

            ID=	tid;
            bitmap=	bmp;
        }

        /// <summary>
        /// Function to calculate new height of the image container as per dimension of the picture
        /// </summary>
        /// <param name="pictureSize">Captured picture size</param>
        /// <param name="imageContainer">Image container whose size is to be changed</param>
        public static void AdjustPictureBoxSize(SD.Size pictureSize, Image imageContainer)
        {
            if (imageContainer != null)
            {
                if (pictureSize.Width > imageContainer.Width)
                {
                    // Calculates and set new height of image container as per photoSize
                    imageContainer.Height = (imageContainer.Width * pictureSize.Height) / pictureSize.Width;

                    imageContainer.Stretch = Stretch.Uniform;
                }
                else
                {
                    imageContainer.Width = imageContainer.Width;
                    imageContainer.Height = pictureSize.Height;
                    imageContainer.Stretch = Stretch.None;
                }
            }
        }

 public Screen(
     Page page,
     drawing::RectangleF box,
     String text,
     String mediaPath,
     String mimeType
     )
     : this(page, box, text,
 new MediaRendition(
   new MediaClipData(
     FileSpecification.Get(
       EmbeddedFile.Get(page.Document, mediaPath),
       System.IO.Path.GetFileName(mediaPath)
       ),
     mimeType
     )
   ))
 {
 }

        public static BitmapSource ToBitmapSource(SD.Bitmap source)
        {
            var hBitmap = source.GetHbitmap();

            try
            {
                return System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                    hBitmap,
                    IntPtr.Zero,
                    Int32Rect.Empty,
                    BitmapSizeOptions.FromEmptyOptions());
            }
            catch (Win32Exception)
            {
                return null;
            }
            finally
            {
                DeleteObject(hBitmap);
            }
        }

        public override void Render(GDI.Graphics g, Map map)
        {
            if (map.Center == null)
                throw (new ApplicationException("Cannot render map. View center not specified"));

            g.SmoothingMode = SmoothingMode;
            var envelope = ToSource(map.Envelope); //View to render

            if (DataSource == null)
                throw (new ApplicationException("DataSource property not set on layer '" + LayerName + "'"));

            // Get the transform
            var transform = new Matrix3x2(g.Transform.Elements);

            // Save state of the graphics object
            var gs = g.Save();

            // Create and prepare the render target
            var rt = RenderTargetFactory.Create(_d2d1Factory, g, map);

            // Set anti-alias mode and transform
            rt.AntialiasMode = AntialiasMode;
            rt.Transform = transform;

            if (Theme != null)
                RenderInternal(_d2d1Factory, rt, map, envelope, Theme);
            else
                RenderInternal(_d2d1Factory, rt, map, envelope);

            // Clean up the render target
            RenderTargetFactory.CleanUp(rt, g, map);
            
            // Restore the graphics object
            g.Restore(gs);

            // Invoke LayerRendered event
            OnLayerRendered(g);
        }

        public D2D1.RenderTarget Create(D2D1.Factory factory, GDI.Graphics g, Map map)
        {
            //Monitor.Enter(_syncRoot);

            // Dispose the _renderTexture if it is instantiated and not of the required size
            CheckTexture(ref _renderTexture, map.Size);

            // Create a new render texture if one is needed
            if (_renderTexture == null)
            {
                _renderTexture = CreateRenderTargetTexture(_d3d11Device, map.Size.Width, map.Size.Height);
            }

            // Get the surface
            var surface = _renderTexture.QueryInterface<DXGI.Surface>();
            
            var res = new D2D1.RenderTarget(factory, surface, new D2D1.RenderTargetProperties(
                D2D1.RenderTargetType.Hardware, new D2D1.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D1.AlphaMode.Premultiplied),
                g.DpiX, g.DpiY, D2D1.RenderTargetUsage.None, D2D1.FeatureLevel.Level_DEFAULT));

            res.BeginDraw();

            return res;
        }