예제 #1
0
        /// <summary>
        ///     Write Multipart Form Data directly to the HttpWebRequest response stream
        /// </summary>
        /// <param name="boundary">Multipart separator</param>
        /// <param name="name">Name of the thing</param>
        /// <param name="formDataStream">Stream to write to</param>
        public void WriteFormDataToStream(string boundary, string name, Stream formDataStream)
        {
            // Add just the first part of this param, since we will write the file data directly to the Stream
            string header = $"--{boundary}\r\nContent-Disposition: form-data; name=\"{name}\"; filename=\"{Filename ?? name}\";\r\nContent-Type: {ContentType}\r\n\r\n";

            formDataStream.Write(Encoding.UTF8.GetBytes(header), 0, Encoding.UTF8.GetByteCount(header));
            ImageOutput.SaveToStream(_surface, formDataStream, _outputSettings);
        }
예제 #2
0
 /// <summary>
 ///     Create a Base64String from the Surface by saving it to a memory stream and converting it.
 ///     Should be avoided if possible, as this uses a lot of memory.
 /// </summary>
 /// <returns>string</returns>
 public string ToBase64String(Base64FormattingOptions formattingOptions)
 {
     using (var stream = new MemoryStream())
     {
         ImageOutput.SaveToStream(_surface, stream, _outputSettings);
         return(Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length, formattingOptions));
     }
 }
예제 #3
0
 /// <summary>
 ///     Create a byte[] from the image by saving it to a memory stream.
 ///     Should be avoided if possible, as this uses a lot of memory.
 /// </summary>
 /// <returns>byte[]</returns>
 public byte[] ToByteArray()
 {
     using (var stream = new MemoryStream())
     {
         ImageOutput.SaveToStream(_surface, stream, _outputSettings);
         return(stream.ToArray());
     }
 }
예제 #4
0
 /// <summary>
 ///     A plain "write data to stream"
 /// </summary>
 /// <param name="dataStream"></param>
 public void WriteToStream(Stream dataStream)
 {
     // Write the file data directly to the Stream, rather than serializing it to a string.
     ImageOutput.SaveToStream(_surface, dataStream, _outputSettings);
 }
예제 #5
0
        /// <summary>
        ///     Set an Image to the clipboard
        ///     This method will place images to the clipboard depending on the ClipboardFormats setting.
        ///     e.g. Bitmap which works with pretty much everything and type Dib for e.g. OpenOffice
        ///     because OpenOffice has a bug http://qa.openoffice.org/issues/show_bug.cgi?id=85661
        ///     The Dib (Device Indenpendend Bitmap) in 32bpp actually won't work with Powerpoint 2003!
        ///     When pasting a Dib in PP 2003 the Bitmap is somehow shifted left!
        ///     For this problem the user should not use the direct paste (=Dib), but select Bitmap
        /// </summary>
        public static void SetClipboardData(ISurface surface)
        {
            var dataObject = new DataObject();

            // This will work for Office and most other applications
            //ido.SetData(DataFormats.Bitmap, true, image);

            MemoryStream dibStream    = null;
            MemoryStream dibV5Stream  = null;
            MemoryStream pngStream    = null;
            Bitmap       bitmapToSave = null;
            var          disposeImage = false;

            try
            {
                var outputSettings = new SurfaceOutputSettings(OutputFormats.png, 100, false);
                // Create the image which is going to be saved so we don't create it multiple times
                disposeImage = ImageOutput.CreateBitmapFromSurface(surface, outputSettings, out bitmapToSave);
                try
                {
                    // Create PNG stream
                    if (CoreConfig.ClipboardFormats.Contains(ClipboardFormats.PNG))
                    {
                        pngStream = new MemoryStream();
                        // PNG works for e.g. Powerpoint
                        var pngOutputSettings = new SurfaceOutputSettings(OutputFormats.png, 100, false);
                        ImageOutput.SaveToStream(bitmapToSave, null, pngStream, pngOutputSettings);
                        pngStream.Seek(0, SeekOrigin.Begin);
                        // Set the PNG stream
                        dataObject.SetData(FORMAT_PNG, false, pngStream);
                    }
                }
                catch (Exception pngEx)
                {
                    Log.Error().WriteLine(pngEx, "Error creating PNG for the Clipboard.");
                }

                try
                {
                    if (CoreConfig.ClipboardFormats.Contains(ClipboardFormats.DIB))
                    {
                        using (var tmpBmpStream = new MemoryStream())
                        {
                            // Save image as BMP
                            var bmpOutputSettings = new SurfaceOutputSettings(OutputFormats.bmp, 100, false);
                            ImageOutput.SaveToStream(bitmapToSave, null, tmpBmpStream, bmpOutputSettings);

                            dibStream = new MemoryStream();
                            // Copy the source, but skip the "BITMAPFILEHEADER" which has a size of 14
                            dibStream.Write(tmpBmpStream.GetBuffer(), BITMAPFILEHEADER_LENGTH, (int)tmpBmpStream.Length - BITMAPFILEHEADER_LENGTH);
                        }

                        // Set the DIB to the clipboard DataObject
                        dataObject.SetData(DataFormats.Dib, true, dibStream);
                    }
                }
                catch (Exception dibEx)
                {
                    Log.Error().WriteLine(dibEx, "Error creating DIB for the Clipboard.");
                }

                // CF_DibV5
                try
                {
                    if (CoreConfig.ClipboardFormats.Contains(ClipboardFormats.DIBV5))
                    {
                        // Create the stream for the clipboard
                        dibV5Stream = new MemoryStream();

                        // Create the BITMAPINFOHEADER
                        var header = BitmapInfoHeader.Create(bitmapToSave.Width, bitmapToSave.Height, 32);
                        // Make sure we have BI_BITFIELDS, this seems to be normal for Format17?
                        header.Compression = BitmapCompressionMethods.BI_BITFIELDS;

                        var headerBytes = BinaryStructHelper.ToByteArray(header);
                        // Write the BITMAPINFOHEADER to the stream
                        dibV5Stream.Write(headerBytes, 0, headerBytes.Length);

                        // As we have specified BI_COMPRESSION.BI_BITFIELDS, the BitfieldColorMask needs to be added
                        var colorMask = BitfieldColorMask.Create();
                        // Create the byte[] from the struct
                        var colorMaskBytes = BinaryStructHelper.ToByteArray(colorMask);
                        Array.Reverse(colorMaskBytes);
                        // Write to the stream
                        dibV5Stream.Write(colorMaskBytes, 0, colorMaskBytes.Length);

                        // Create the raw bytes for the pixels only
                        var bitmapBytes = BitmapToByteArray(bitmapToSave);
                        // Write to the stream
                        dibV5Stream.Write(bitmapBytes, 0, bitmapBytes.Length);

                        // Set the DIBv5 to the clipboard DataObject
                        dataObject.SetData(FORMAT_17, true, dibV5Stream);
                    }
                }
                catch (Exception dibEx)
                {
                    Log.Error().WriteLine(dibEx, "Error creating DIB for the Clipboard.");
                }

                // Set the HTML
                if (CoreConfig.ClipboardFormats.Contains(ClipboardFormats.HTML))
                {
                    var tmpFile = ImageOutput.SaveToTmpFile(surface, new SurfaceOutputSettings(OutputFormats.png, 100, false), null);
                    var html    = GetHtmlString(surface, tmpFile);
                    dataObject.SetText(html, TextDataFormat.Html);
                }
                else if (CoreConfig.ClipboardFormats.Contains(ClipboardFormats.HTMLDATAURL))
                {
                    string html;
                    using (var tmpPngStream = new MemoryStream())
                    {
                        var pngOutputSettings = new SurfaceOutputSettings(OutputFormats.png, 100, false)
                        {
                            // Do not allow to reduce the colors, some applications dislike 256 color images
                            // reported with bug #3594681
                            DisableReduceColors = true
                        };
                        // Check if we can use the previously used image
                        if (bitmapToSave.PixelFormat != PixelFormat.Format8bppIndexed)
                        {
                            ImageOutput.SaveToStream(bitmapToSave, surface, tmpPngStream, pngOutputSettings);
                        }
                        else
                        {
                            ImageOutput.SaveToStream(surface, tmpPngStream, pngOutputSettings);
                        }
                        html = GetHtmlDataUrlString(surface, tmpPngStream);
                    }
                    dataObject.SetText(html, TextDataFormat.Html);
                }
            }
            finally
            {
                // we need to use the SetDataOject before the streams are closed otherwise the buffer will be gone!
                // Check if Bitmap is wanted
                if (CoreConfig.ClipboardFormats.Contains(ClipboardFormats.BITMAP))
                {
                    dataObject.SetImage(bitmapToSave);
                    // Place the DataObject to the clipboard
                    SetDataObject(dataObject, true);
                }
                else
                {
                    // Place the DataObject to the clipboard
                    SetDataObject(dataObject, true);
                }

                pngStream?.Dispose();
                dibStream?.Dispose();
                dibV5Stream?.Dispose();
                // cleanup if needed
                if (disposeImage)
                {
                    bitmapToSave?.Dispose();
                }
            }
        }