Example #1
0
        public virtual ImageCodecInfo GetCodecInfo(ImageFormatTypes type)
        {
            string mimeType = GetMimeType(type);

            if (!string.IsNullOrEmpty(mimeType))
            {
                for (int i = 0; i < 2; i++)
                {
                    ImageCodecInfo[] infoArray;
                    if (i == 0)
                    {
                        infoArray = this.imageCodecInfo_0;
                    }
                    else
                    {
                        infoArray = this.imageCodecInfo_1;
                    }
                    foreach (ImageCodecInfo info in infoArray)
                    {
                        if (info.MimeType == mimeType)
                        {
                            return(info);
                        }
                    }
                }
            }
            return(null);
        }
 public static ImageFormat GetImageFormat(ImageFormatTypes type)
 {
     switch (type)
     {
         case ImageFormatTypes.imgBMP:
             return ImageFormat.Bmp;
         case ImageFormatTypes.imgEMF:
             return ImageFormat.Emf;
         case ImageFormatTypes.imgEXIF:
             return ImageFormat.Exif;
         case ImageFormatTypes.imgGIF:
             return ImageFormat.Gif;
         case ImageFormatTypes.imgICON:
             return ImageFormat.Icon;
         case ImageFormatTypes.imgJPEG:
             return ImageFormat.Jpeg;
         case ImageFormatTypes.imgPNG:
             return ImageFormat.Png;
         case ImageFormatTypes.imgTIFF:
             return ImageFormat.Tiff;
         case ImageFormatTypes.imgWMF:
             return ImageFormat.Wmf;
         default:
             return null;
     }
 }
Example #3
0
        public virtual Bitmap CaptureControl(Control window, string filename, ImageFormatTypes format)
        {
            this.CaptureControl(window);

            if (Settings.EnableCaptureToFolder)
                this.Save(filename, format);

            return this.images[0];
        }
Example #4
0
        public virtual string GetDefaultFilenameExtension(ImageFormatTypes type)
        {
            string         str       = "";
            ImageCodecInfo codecInfo = this.GetCodecInfo(type);

            if (codecInfo != null)
            {
                str = codecInfo.FilenameExtension.Split(new char[] { ';' })[0];
                if (str.StartsWith("*."))
                {
                    str = str.Substring(2);
                }
            }
            return(str);
        }
Example #5
0
        public virtual EncoderParameters GetEncoderParameters(ImageFormatTypes type, out ImageCodecInfo info)
        {
            EncoderParameters parameters = null;

            info = this.GetCodecInfo(type);
            if (info != null)
            {
                EncoderParameter parameter;
                switch (type)
                {
                case ImageFormatTypes.imgGIF:
                    parameters          = new EncoderParameters(2);
                    parameter           = new EncoderParameter(Encoder.Version, 10);
                    parameters.Param[0] = parameter;
                    parameter           = new EncoderParameter(Encoder.ScanMethod, (long)this.encoderValue_1);
                    parameters.Param[1] = parameter;
                    return(parameters);

                case ImageFormatTypes.imgICON:
                    return(parameters);

                case ImageFormatTypes.imgJPEG:
                    parameters          = new EncoderParameters(2);
                    parameter           = new EncoderParameter(Encoder.RenderMethod, (long)this.encoderValue_0);
                    parameters.Param[0] = parameter;
                    parameter           = new EncoderParameter(Encoder.Quality, this.long_0);
                    parameters.Param[1] = parameter;
                    return(parameters);

                case ImageFormatTypes.imgPNG:
                    parameters          = new EncoderParameters(2);
                    parameter           = new EncoderParameter(Encoder.RenderMethod, (long)this.encoderValue_0);
                    parameters.Param[0] = parameter;
                    parameter           = new EncoderParameter(Encoder.ScanMethod, (long)this.encoderValue_1);
                    parameters.Param[1] = parameter;
                    return(parameters);

                case ImageFormatTypes.imgTIFF:
                    parameters          = new EncoderParameters(2);
                    parameter           = new EncoderParameter(Encoder.ColorDepth, this.long_1);
                    parameters.Param[0] = parameter;
                    parameter           = new EncoderParameter(Encoder.Compression, (long)this.encoderValue_2);
                    parameters.Param[1] = parameter;
                    return(parameters);
                }
            }
            return(parameters);
        }
Example #6
0
        /// <summary>
        /// Get the default filename extension for a given type
        /// </summary>
        /// <param name="type">The image type</param>
        /// <returns>The extension string.</returns>
        public virtual String GetDefaultFilenameExtension(ImageFormatTypes type)
        {
            String         ext  = "";
            ImageCodecInfo info = GetCodecInfo(type);

            if (info != null)
            {
                String[] extensions = info.FilenameExtension.Split(new char[] { ';' });
                ext = extensions[0];
                if (ext.StartsWith("*."))
                {
                    ext = ext.Substring(2);
                }
            }
            return(ext);
        }
        public static string GetMimeType(ImageFormatTypes type)
        {
            string s = null;
            switch (type)
            {
                case ImageFormatTypes.imgBMP:
                    s = "bmp";
                    break;
                case ImageFormatTypes.imgEMF:
                    s = "x-emf";
                    break;
                case ImageFormatTypes.imgGIF:
                    s = "gif";
                    break;
                case ImageFormatTypes.imgICON:
                    s = "x-icon";
                    break;
                case ImageFormatTypes.imgJPEG:
                    s = "jpeg";
                    break;
                case ImageFormatTypes.imgPNG:
                    s = "png";
                    break;
                case ImageFormatTypes.imgTIFF:
                    s = "tiff";
                    break;
                case ImageFormatTypes.imgWMF:
                    s = "x-wmf";
                    break;
            }

            if (!String.IsNullOrEmpty(s))
                s = string.Format("image/{0}", s);

            return s;
        }
Example #8
0
 public virtual Bitmap Capture(IntPtr handle, string filename, ImageFormatTypes format)
 {
     this.Capture(handle);
     this.Save(filename, format);
     return this.images[0];
 }
Example #9
0
 public virtual Bitmap Capture(Form window, string filename, ImageFormatTypes format, bool onlyClient)
 {
     this.Capture(window, onlyClient);
     this.Save(filename, format);
     return this.images[0];
 }
Example #10
0
 public virtual Bitmap Capture(Form window, string filename, ImageFormatTypes format)
 {
     return this.Capture(window, filename, format, false);
 }
Example #11
0
        public virtual void Save(string filename, ImageFormatTypes format)
        {
            string directory = Path.GetDirectoryName(filename);
            string name = Path.GetFileNameWithoutExtension(filename);
            string ext = Path.GetExtension(filename);

            ext = this.formatHandler.GetDefaultFilenameExtension(format);

            if (ext.Length == 0)
            {
                format = ImageFormatTypes.imgPNG;
                ext = "png";
            }

            try
            {
                ImageCodecInfo info;
                EncoderParameters parameters = this.formatHandler.GetEncoderParameters(format, out info);

                for (int i = 0; i < this.images.Length; i++)
                {
                    if (this.images.Length > 1)
                    {
                        filename = string.Format("{0}\\{1}.{2:D2}.{3}",
                                                 directory, name, i + 1, ext);
                    }
                    else
                    {
                        filename = string.Format("{0}\\{1}.{2}",
                                                 directory, name, ext);
                    }

                    this.image = this.images[i];

                    if (parameters != null)
                    {
                        this.image.Save(filename, info, parameters);
                    }
                    else
                    {
                        this.image.Save(filename, ImageFormatHandler.GetImageFormat(format));
                    }
                }
            }
            catch (Exception ex)
            {
                string s = string.Format("Saving image to [{0}] in format [{1}] failed.\n{2}", filename,
                                         format.ToString(), ex);
                Log.Error(s, ex);
                MessageBox.Show(s, "Screen capture failed.",
                                MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Example #12
0
 public virtual Bitmap[] Capture(CaptureType typeOfCapture, string filename, ImageFormatTypes format)
 {
     this.Capture(typeOfCapture);
     this.Save(filename, format);
     return this.images;
 }
        public virtual EncoderParameters GetEncoderParameters(ImageFormatTypes type, out ImageCodecInfo info)
        {
            EncoderParameters parameters = null;
            info = GetCodecInfo(type);
            if (info != null)
            {
                System.Drawing.Imaging.Encoder encode;
                EncoderParameter param;
                switch (type)
                {
                    case ImageFormatTypes.imgGIF:
                        parameters = new EncoderParameters(2);
                        encode = System.Drawing.Imaging.Encoder.Version;
                        param = new EncoderParameter(encode, (long)EncoderValue.VersionGif89);
                        parameters.Param[0] = param;

                        encode = System.Drawing.Imaging.Encoder.ScanMethod;
                        param = new EncoderParameter(encode, (long)encodingScanMethod);
                        parameters.Param[1] = param;
                        break;

                    case ImageFormatTypes.imgJPEG:
                        parameters = new EncoderParameters(2);
                        encode = System.Drawing.Imaging.Encoder.RenderMethod;
                        param = new EncoderParameter(encode, (long)encodingRenderMethod);
                        parameters.Param[0] = param;

                        encode = System.Drawing.Imaging.Encoder.Quality;
                        param = new EncoderParameter(encode, encodingQuality);
                        parameters.Param[1] = param;
                        break;

                    case ImageFormatTypes.imgPNG:
                        parameters = new EncoderParameters(2);
                        encode = System.Drawing.Imaging.Encoder.RenderMethod;
                        param = new EncoderParameter(encode, (long)encodingRenderMethod);
                        parameters.Param[0] = param;

                        encode = System.Drawing.Imaging.Encoder.ScanMethod;
                        param = new EncoderParameter(encode, (long)encodingScanMethod);
                        parameters.Param[1] = param;
                        break;

                    case ImageFormatTypes.imgTIFF:
                        parameters = new EncoderParameters(2);
                        encode = System.Drawing.Imaging.Encoder.ColorDepth;
                        param = new EncoderParameter(encode, encodingColorDepth);
                        parameters.Param[0] = param;

                        encode = System.Drawing.Imaging.Encoder.Compression;
                        param = new EncoderParameter(encode, (long)encodingCompression);
                        parameters.Param[1] = param;
                        break;
                }
            }
            return parameters;
        }
        public virtual String GetDefaultFilenameExtension(ImageFormatTypes type)
        {
            String ext = "";
            ImageCodecInfo info = GetCodecInfo(type);

            if (info != null)
            {
                String[] extensions = info.FilenameExtension.Split(new char[] { ';' });
                ext = extensions[0];
                if (ext.StartsWith("*."))
                    ext = ext.Substring(2);
            }
            return ext;
        }
        public virtual ImageCodecInfo GetCodecInfo(ImageFormatTypes type)
        {
            ImageCodecInfo[] encoders;

            String mimeType = GetMimeType(type);

            if (!String.IsNullOrEmpty(mimeType))
            {
                for (int i = 0; i < 2; i++)
                {
                    if (i == 0)
                        encoders = availableEncoders;
                    else
                        encoders = availableDecoders;

                    foreach (ImageCodecInfo info in encoders)
                    {
                        if (info.MimeType == mimeType)
                            return info;
                    }
                }
            }
            return null;
        }