public IntPtr ReadFile(MagickSettings settings) { using (INativeInstance settingsNative = MagickSettings.CreateInstance(settings)) { IntPtr exception = IntPtr.Zero; IntPtr result; if (NativeLibrary.Is64Bit) { result = NativeMethods.X64.MagickImageCollection_ReadFile(settingsNative.Instance, out exception); } else { result = NativeMethods.X86.MagickImageCollection_ReadFile(settingsNative.Instance, out exception); } MagickException magickException = MagickExceptionHelper.Create(exception); if (MagickExceptionHelper.IsError(magickException)) { if (result != IntPtr.Zero) { Dispose(result); } throw magickException; } RaiseWarning(magickException); return(result); } }
public IntPtr WriteStream(MagickImage image, MagickSettings settings, ReadWriteStreamDelegate reader, ReadWriteStreamDelegate writer, SeekStreamDelegate seeker, TellStreamDelegate teller) { using (INativeInstance settingsNative = MagickSettings.CreateInstance(settings)) { IntPtr exception = IntPtr.Zero; IntPtr result; #if ANYCPU if (NativeLibrary.Is64Bit) #endif #if WIN64 || ANYCPU result = NativeMethods.X64.MagickImageCollection_WriteStream(MagickImage.GetInstance(image), settingsNative.Instance, reader, writer, seeker, teller, out exception); #endif #if ANYCPU else #endif #if !WIN64 || ANYCPU result = NativeMethods.X86.MagickImageCollection_WriteStream(MagickImage.GetInstance(image), settingsNative.Instance, reader, writer, seeker, teller, out exception); #endif MagickException magickException = MagickExceptionHelper.Create(exception); if (MagickExceptionHelper.IsError(magickException)) { if (result != IntPtr.Zero) { Dispose(result); } throw magickException; } RaiseWarning(magickException); return(result); } }
public IntPtr ReadBlob(MagickSettings settings, byte[] data, int length) { using (INativeInstance settingsNative = MagickSettings.CreateInstance(settings)) { IntPtr exception = IntPtr.Zero; IntPtr result; #if ANYCPU if (NativeLibrary.Is64Bit) #endif #if WIN64 || ANYCPU result = NativeMethods.X64.MagickImageCollection_ReadBlob(settingsNative.Instance, data, (UIntPtr)length, out exception); #endif #if ANYCPU else #endif #if !WIN64 || ANYCPU result = NativeMethods.X86.MagickImageCollection_ReadBlob(settingsNative.Instance, data, (UIntPtr)length, out exception); #endif MagickException magickException = MagickExceptionHelper.Create(exception); if (MagickExceptionHelper.IsError(magickException)) { if (result != IntPtr.Zero) { Dispose(result); } throw magickException; } RaiseWarning(magickException); return(result); } }
/// <summary> /// Copies the settings from the specified <see cref="MagickSettings"/>. /// </summary> /// <param name="settings">The settings to copy the data from.</param> protected void Copy(MagickSettings settings) { if (settings == null) { return; } BackgroundColor = MagickColor.Clone(settings.BackgroundColor); ColorSpace = settings.ColorSpace; ColorType = settings.ColorType; CompressionMethod = settings.CompressionMethod; Debug = settings.Debug; Density = Density.Clone(settings.Density); Endian = settings.Endian; Extract = MagickGeometry.Clone(settings.Extract); _font = settings._font; _fontPointsize = settings._fontPointsize; Format = settings.Format; Monochrome = settings.Monochrome; Page = MagickGeometry.Clone(settings.Page); Verbose = settings.Verbose; ColorFuzz = settings.ColorFuzz; Interlace = settings.Interlace; Ping = settings.Ping; Quality = settings.Quality; Size = settings.Size; foreach (string key in settings._options.Keys) { _options[key] = settings._options[key]; } Drawing = settings.Drawing.Clone(); }
public IntPtr ReadBlob(MagickSettings settings, byte[] data, int length) { IntPtr exception = IntPtr.Zero; IntPtr result; if (NativeLibrary.Is64Bit) { result = NativeMethods.X64.MagickImageCollection_ReadBlob(MagickSettings.GetInstance(settings), data, (UIntPtr)length, out exception); } else { result = NativeMethods.X86.MagickImageCollection_ReadBlob(MagickSettings.GetInstance(settings), data, (UIntPtr)length, out exception); } MagickException magickException = MagickExceptionHelper.Create(exception); if (MagickExceptionHelper.IsError(magickException)) { if (result != IntPtr.Zero) { Dispose(result); } throw magickException; } RaiseWarning(magickException); return(result); }
private void ExecuteRemoveDefine(XmlElement element, MagickSettings settings) { Hashtable arguments = new Hashtable(); foreach (XmlAttribute attribute in element.Attributes) { if (attribute.Name == "format") { arguments["format"] = Variables.GetValue <MagickFormat>(attribute); } else if (attribute.Name == "name") { arguments["name"] = Variables.GetValue <String>(attribute); } } if (OnlyContains(arguments, "format", "name")) { settings.RemoveDefine((MagickFormat)arguments["format"], (String)arguments["name"]); } else if (OnlyContains(arguments, "name")) { settings.RemoveDefine((String)arguments["name"]); } else { throw new ArgumentException("Invalid argument combination for 'removeDefine', allowed combinations are: [format, name] [name]"); } }
public IntPtr ReadFile(IMagickSettings <QuantumType> settings) { using (INativeInstance settingsNative = MagickSettings.CreateInstance(settings)) { IntPtr exception = IntPtr.Zero; IntPtr result; #if PLATFORM_AnyCPU if (NativeLibrary.Is64Bit) #endif #if PLATFORM_x64 || PLATFORM_AnyCPU result = NativeMethods.X64.MagickImageCollection_ReadFile(settingsNative.Instance, out exception); #endif #if PLATFORM_AnyCPU else #endif #if PLATFORM_x86 || PLATFORM_AnyCPU result = NativeMethods.X86.MagickImageCollection_ReadFile(settingsNative.Instance, out exception); #endif var magickException = MagickExceptionHelper.Create(exception); if (magickException == null) { return(result); } if (magickException is MagickErrorException) { if (result != IntPtr.Zero) { Dispose(result); } throw magickException; } RaiseWarning(magickException); return(result); } }
public IntPtr ReadBlob(MagickSettings settings, byte[] data, int offset, int length) { using (INativeInstance settingsNative = MagickSettings.CreateInstance(settings)) { IntPtr exception = IntPtr.Zero; IntPtr result; #if PLATFORM_AnyCPU if (NativeLibrary.Is64Bit) #endif #if PLATFORM_x64 || PLATFORM_AnyCPU result = NativeMethods.X64.MagickImageCollection_ReadBlob(settingsNative.Instance, data, (UIntPtr)offset, (UIntPtr)length, out exception); #endif #if PLATFORM_AnyCPU else #endif #if PLATFORM_x86 || PLATFORM_AnyCPU result = NativeMethods.X86.MagickImageCollection_ReadBlob(settingsNative.Instance, data, (UIntPtr)offset, (UIntPtr)length, out exception); #endif var magickException = MagickExceptionHelper.Create(exception); if (magickException == null) { return(result); } if (magickException is MagickErrorException) { if (result != IntPtr.Zero) { Dispose(result); } throw magickException; } RaiseWarning(magickException); return(result); } }
private void AddImages(IntPtr result, MagickSettings settings) { foreach (MagickImage image in MagickImage.CreateList(result, settings)) { _Images.Add(image); } }
///<summary> /// Writes the imagse to the specified stream. If the output image's file format does not /// allow multi-image files multiple files will be written. ///</summary> ///<param name="stream">The stream to write the images to.</param> ///<exception cref="MagickException"/> public void Write(Stream stream) { Throw.IfNull("stream", stream); if (_Images.Count == 0) { return; } MagickSettings settings = _Images[0].Settings; settings.FileName = null; try { AttachImages(); UIntPtr length; IntPtr data = _NativeInstance.WriteBlob(_Images[0], settings, out length); MagickMemory.WriteBytes(data, length, stream); } finally { DetachImages(); } }
public IntPtr WriteBlob(MagickImage image, MagickSettings settings, out UIntPtr length) { using (INativeInstance settingsNative = MagickSettings.CreateInstance(settings)) { IntPtr exception = IntPtr.Zero; IntPtr result; if (NativeLibrary.Is64Bit) { result = NativeMethods.X64.MagickImageCollection_WriteBlob(MagickImage.GetInstance(image), settingsNative.Instance, out length, out exception); } else { result = NativeMethods.X86.MagickImageCollection_WriteBlob(MagickImage.GetInstance(image), settingsNative.Instance, out length, out exception); } MagickException magickException = MagickExceptionHelper.Create(exception); if (MagickExceptionHelper.IsError(magickException)) { if (result != IntPtr.Zero) { MagickMemory.Relinquish(result); } throw magickException; } RaiseWarning(magickException); return(result); } }
public IntPtr ReadStream(MagickSettings settings, ReadWriteStreamDelegate reader, SeekStreamDelegate seeker, TellStreamDelegate teller) { using (INativeInstance settingsNative = MagickSettings.CreateInstance(settings)) { IntPtr exception = IntPtr.Zero; IntPtr result; #if PLATFORM_AnyCPU if (NativeLibrary.Is64Bit) #endif #if PLATFORM_x64 || PLATFORM_AnyCPU result = NativeMethods.X64.MagickImageCollection_ReadStream(settingsNative.Instance, reader, seeker, teller, out exception); #endif #if PLATFORM_AnyCPU else #endif #if PLATFORM_x86 || PLATFORM_AnyCPU result = NativeMethods.X86.MagickImageCollection_ReadStream(settingsNative.Instance, reader, seeker, teller, out exception); #endif var magickException = MagickExceptionHelper.Create(exception); if (magickException == null) { return(result); } if (magickException is MagickErrorException) { if (result != IntPtr.Zero) { Dispose(result); } throw magickException; } RaiseWarning(magickException); return(result); } }
internal static IntPtr GetInstance(MagickSettings instance) { if (instance == null) { return(IntPtr.Zero); } return(instance._NativeInstance.Instance); }
internal MagickSettings Clone() { MagickSettings clone = new MagickSettings(); clone.Copy(this); return(clone); }
internal static INativeInstance CreateInstance(IMagickSettings <QuantumType> instance) { if (instance == null) { return(NativeInstance.Zero); } return(MagickSettings.CreateNativeInstance(instance)); }
internal static INativeInstance CreateInstance(MagickSettings instance) { if (instance == null) { return(NativeInstance.Zero); } return(instance.CreateNativeInstance()); }
private void AddImages(byte[] data, MagickReadSettings readSettings, bool ping) { Throw.IfNullOrEmpty(nameof(data), data); MagickSettings settings = CreateSettings(readSettings); settings.Ping = ping; IntPtr result = _NativeInstance.ReadBlob(settings, data, data.Length); AddImages(result, settings); }
public void WriteFile(MagickImage image, MagickSettings settings) { IntPtr exception = IntPtr.Zero; if (NativeLibrary.Is64Bit) { NativeMethods.X64.MagickImageCollection_WriteFile(MagickImage.GetInstance(image), MagickSettings.GetInstance(settings), out exception); } else { NativeMethods.X86.MagickImageCollection_WriteFile(MagickImage.GetInstance(image), MagickSettings.GetInstance(settings), out exception); } CheckException(exception); }
private void AddImages(string fileName, MagickReadSettings readSettings, bool ping) { string filePath = FileHelper.CheckForBaseDirectory(fileName); Throw.IfInvalidFileName(filePath); MagickSettings settings = CreateSettings(readSettings); settings.FileName = filePath; settings.Ping = ping; IntPtr result = _NativeInstance.ReadFile(settings); AddImages(result, settings); }
private void AddImages(byte[] data, MagickReadSettings readSettings, bool ping) { Throw.IfNullOrEmpty("data", data); CheckReadSettings(readSettings); using (MagickSettings settings = new MagickSettings()) { settings.Apply(readSettings); settings.Ping = ping; IntPtr result = _NativeInstance.ReadBlob(settings, data, data.Length); AddImages(result, settings); } }
public void WriteFile(MagickImage image, MagickSettings settings) { using (INativeInstance settingsNative = MagickSettings.CreateInstance(settings)) { IntPtr exception = IntPtr.Zero; #if ANYCPU if (NativeLibrary.Is64Bit) #endif #if WIN64 || ANYCPU NativeMethods.X64.MagickImageCollection_WriteFile(MagickImage.GetInstance(image), settingsNative.Instance, out exception); #endif #if ANYCPU else #endif #if !WIN64 || ANYCPU NativeMethods.X86.MagickImageCollection_WriteFile(MagickImage.GetInstance(image), settingsNative.Instance, out exception); #endif CheckException(exception); } }
public void WriteStream(IMagickImage image, IMagickSettings <QuantumType> settings, ReadWriteStreamDelegate writer, SeekStreamDelegate seeker, TellStreamDelegate teller, ReadWriteStreamDelegate reader) { using (INativeInstance settingsNative = MagickSettings.CreateInstance(settings)) { IntPtr exception = IntPtr.Zero; #if PLATFORM_AnyCPU if (OperatingSystem.Is64Bit) #endif #if PLATFORM_x64 || PLATFORM_AnyCPU NativeMethods.X64.MagickImageCollection_WriteStream(image.GetInstance(), settingsNative.Instance, writer, seeker, teller, reader, out exception); #endif #if PLATFORM_AnyCPU else #endif #if PLATFORM_x86 || PLATFORM_AnyCPU NativeMethods.X86.MagickImageCollection_WriteStream(image.GetInstance(), settingsNative.Instance, writer, seeker, teller, reader, out exception); #endif CheckException(exception); } }
public void WriteFile(IMagickImage image, IMagickSettings <QuantumType> settings) { using (INativeInstance settingsNative = MagickSettings.CreateInstance(settings)) { IntPtr exception = IntPtr.Zero; #if PLATFORM_AnyCPU if (OperatingSystem.Is64Bit) #endif #if PLATFORM_x64 || PLATFORM_AnyCPU NativeMethods.X64.MagickImageCollection_WriteFile(image.GetInstance(), settingsNative.Instance, out exception); #endif #if PLATFORM_AnyCPU else #endif #if PLATFORM_x86 || PLATFORM_AnyCPU NativeMethods.X86.MagickImageCollection_WriteFile(image.GetInstance(), settingsNative.Instance, out exception); #endif CheckException(exception); } }
///<summary> /// Writes the images to the specified file name. If the output image's file format does not /// allow multi-image files multiple files will be written. ///</summary> ///<param name="fileName">The fully qualified name of the image file, or the relative image file name.</param> ///<exception cref="MagickException"/> public void Write(string fileName) { string filePath = FileHelper.CheckForBaseDirectory(fileName); if (_Images.Count == 0) { return; } MagickSettings settings = _Images[0].Settings; settings.FileName = fileName; try { AttachImages(); _NativeInstance.WriteFile(_Images[0], settings); } finally { DetachImages(); } }
///<summary> /// OptimizePlus is exactly as Optimize, but may also add or even remove extra frames in the /// animation, if it improves the total number of pixels in the resulting GIF animation. ///</summary> ///<exception cref="MagickException"/> public void OptimizePlus() { ThrowIfEmpty(); using (MagickSettings settings = _Images[0].Settings.Clone()) { IntPtr images; try { AttachImages(); images = _NativeInstance.OptimizePlus(_Images[0]); } finally { DetachImages(); } Clear(); foreach (MagickImage image in MagickImage.CreateList(images, settings)) { Add(image); } } }
///<summary> /// Break down an image sequence into constituent parts. This is useful for creating GIF or /// MNG animation sequences. ///</summary> ///<exception cref="MagickException"/> public void Deconstruct() { ThrowIfEmpty(); MagickSettings settings = _Images[0].Settings.Clone(); IntPtr images; try { AttachImages(); images = _NativeInstance.Deconstruct(_Images[0]); } finally { DetachImages(); } Clear(); foreach (MagickImage image in MagickImage.CreateList(images, settings)) { Add(image); } }
///<summary> /// The Morph method requires a minimum of two images. The first image is transformed into /// the second by a number of intervening images as specified by frames. ///</summary> ///<param name="frames">The number of in-between images to generate.</param> ///<exception cref="MagickException"/> public void Morph(int frames) { ThrowIfCountLowerThan(2); using (MagickSettings settings = _Images[0].Settings.Clone()) { IntPtr images; try { AttachImages(); images = _NativeInstance.Morph(_Images[0], frames); } finally { DetachImages(); } Clear(); foreach (MagickImage image in MagickImage.CreateList(images, settings)) { Add(image); } } }
internal MagickReadSettings(MagickSettings settings) { Copy(settings); }
private void ExecuteCompressionMethod(XmlElement element, MagickSettings settings) { settings.CompressionMethod = Variables.GetValue<CompressionMethod>(element, "value"); }
private void ExecuteSetDefines(XmlElement element, MagickSettings settings) { IDefines defines_ = CreateIDefines(element["defines"]); settings.SetDefines(defines_); }
private void ExecuteVerbose(XmlElement element, MagickSettings settings) { settings.Verbose = Variables.GetValue<Boolean>(element, "value"); }
private void ExecuteTextKerning(XmlElement element, MagickSettings settings) { settings.TextKerning = Variables.GetValue<double>(element, "value"); }
private void ExecuteTextEncoding(XmlElement element, MagickSettings settings) { settings.TextEncoding = Variables.GetValue<Encoding>(element, "value"); }
private void ExecuteTextAntiAlias(XmlElement element, MagickSettings settings) { settings.TextAntiAlias = Variables.GetValue<Boolean>(element, "value"); }
private void ExecuteFontPointsize(XmlElement element, MagickSettings settings) { settings.FontPointsize = Variables.GetValue<double>(element, "value"); }
private void ExecuteFontFamily(XmlElement element, MagickSettings settings) { settings.FontFamily = Variables.GetValue<String>(element, "value"); }
private void ExecuteMagickSettings(XmlElement element, MagickSettings settings) { switch(element.Name[0]) { case 'b': { switch(element.Name[1]) { case 'a': { ExecuteBackgroundColor(element, settings); return; } case 'o': { ExecuteBorderColor(element, settings); return; } } break; } case 'c': { switch(element.Name[2]) { case 'l': { switch(element.Name[5]) { case 'S': { ExecuteColorSpace(element, settings); return; } case 'T': { ExecuteColorType(element, settings); return; } } break; } case 'm': { ExecuteCompressionMethod(element, settings); return; } } break; } case 'd': { switch(element.Name[2]) { case 'b': { ExecuteDebug(element, settings); return; } case 'n': { ExecuteDensity(element, settings); return; } } break; } case 'e': { ExecuteEndian(element, settings); return; } case 'f': { switch(element.Name[1]) { case 'i': { switch(element.Name[4]) { case 'C': { ExecuteFillColor(element, settings); return; } case 'P': { ExecuteFillPattern(element, settings); return; } case 'R': { ExecuteFillRule(element, settings); return; } } break; } case 'o': { switch(element.Name[2]) { case 'n': { if (element.Name.Length == 4) { ExecuteFont(element, settings); return; } switch(element.Name[4]) { case 'F': { ExecuteFontFamily(element, settings); return; } case 'P': { ExecuteFontPointsize(element, settings); return; } case 'S': { ExecuteFontStyle(element, settings); return; } case 'W': { ExecuteFontWeight(element, settings); return; } } break; } case 'r': { ExecuteFormat(element, settings); return; } } break; } } break; } case 'p': { ExecutePage(element, settings); return; } case 's': { switch(element.Name[1]) { case 't': { switch(element.Name[6]) { case 'A': { ExecuteStrokeAntiAlias(element, settings); return; } case 'C': { ExecuteStrokeColor(element, settings); return; } case 'D': { switch(element.Name[10]) { case 'A': { ExecuteStrokeDashArray(element, settings); return; } case 'O': { ExecuteStrokeDashOffset(element, settings); return; } } break; } case 'L': { switch(element.Name[10]) { case 'C': { ExecuteStrokeLineCap(element, settings); return; } case 'J': { ExecuteStrokeLineJoin(element, settings); return; } } break; } case 'M': { ExecuteStrokeMiterLimit(element, settings); return; } case 'P': { ExecuteStrokePattern(element, settings); return; } case 'W': { ExecuteStrokeWidth(element, settings); return; } } break; } case 'e': { if (element.Name.Length == 9) { ExecuteSetDefine(element, settings); return; } if (element.Name.Length == 10) { ExecuteSetDefines(element, settings); return; } break; } } break; } case 't': { switch(element.Name[4]) { case 'A': { ExecuteTextAntiAlias(element, settings); return; } case 'D': { ExecuteTextDirection(element, settings); return; } case 'E': { ExecuteTextEncoding(element, settings); return; } case 'G': { ExecuteTextGravity(element, settings); return; } case 'I': { switch(element.Name[9]) { case 'l': { ExecuteTextInterlineSpacing(element, settings); return; } case 'w': { ExecuteTextInterwordSpacing(element, settings); return; } } break; } case 'K': { ExecuteTextKerning(element, settings); return; } case 'U': { ExecuteTextUnderColor(element, settings); return; } } break; } case 'v': { ExecuteVerbose(element, settings); return; } case 'r': { ExecuteRemoveDefine(element, settings); return; } } throw new NotSupportedException(element.Name); }
private void ExecuteFillRule(XmlElement element, MagickSettings settings) { settings.FillRule = Variables.GetValue<FillRule>(element, "value"); }
private void ExecuteDensity(XmlElement element, MagickSettings settings) { settings.Density = Variables.GetValue<Density>(element, "value"); }
private void ExecuteDebug(XmlElement element, MagickSettings settings) { settings.Debug = Variables.GetValue<Boolean>(element, "value"); }
private void ExecuteStrokePattern(XmlElement element, MagickSettings settings) { settings.StrokePattern = CreateMagickImage(element); }
private void ExecuteFontStyle(XmlElement element, MagickSettings settings) { settings.FontStyle = Variables.GetValue<FontStyleType>(element, "value"); }
private void ExecuteStrokeWidth(XmlElement element, MagickSettings settings) { settings.StrokeWidth = Variables.GetValue<double>(element, "value"); }
private void ExecuteFontWeight(XmlElement element, MagickSettings settings) { settings.FontWeight = Variables.GetValue<FontWeight>(element, "value"); }
private void ExecuteTextDirection(XmlElement element, MagickSettings settings) { settings.TextDirection = Variables.GetValue<TextDirection>(element, "value"); }
private void ExecuteFormat(XmlElement element, MagickSettings settings) { settings.Format = Variables.GetValue<MagickFormat>(element, "value"); }
private void ExecuteTextGravity(XmlElement element, MagickSettings settings) { settings.TextGravity = Variables.GetValue<Gravity>(element, "value"); }
private static void ExecuteResetTransform(MagickSettings settings) { settings.ResetTransform(); }
private void ExecuteTextUnderColor(XmlElement element, MagickSettings settings) { settings.TextUnderColor = Variables.GetValue<MagickColor>(element, "value"); }
private void ExecuteSetTransformSkewY(XmlElement element, MagickSettings settings) { double value_ = Variables.GetValue <double>(element, "value"); settings.SetTransformSkewY(value_); }
private void ExecuteSetDefine(XmlElement element, MagickSettings settings) { Hashtable arguments = new Hashtable(); foreach (XmlAttribute attribute in element.Attributes) { if (attribute.Name == "flag") arguments["flag"] = Variables.GetValue<Boolean>(attribute); else if (attribute.Name == "format") arguments["format"] = Variables.GetValue<MagickFormat>(attribute); else if (attribute.Name == "name") arguments["name"] = Variables.GetValue<String>(attribute); else if (attribute.Name == "value") arguments["value"] = Variables.GetValue<String>(attribute); } if (OnlyContains(arguments, "format", "name", "flag")) settings.SetDefine((MagickFormat)arguments["format"], (String)arguments["name"], (Boolean)arguments["flag"]); else if (OnlyContains(arguments, "format", "name", "value")) settings.SetDefine((MagickFormat)arguments["format"], (String)arguments["name"], (String)arguments["value"]); else if (OnlyContains(arguments, "name", "value")) settings.SetDefine((String)arguments["name"], (String)arguments["value"]); else throw new ArgumentException("Invalid argument combination for 'setDefine', allowed combinations are: [format, name, flag] [format, name, value] [name, value]"); }
private void ExecuteBackgroundColor(XmlElement element, MagickSettings settings) { settings.BackgroundColor = Variables.GetValue<MagickColor>(element, "value"); }
private void ExecutePage(XmlElement element, MagickSettings settings) { settings.Page = Variables.GetValue<MagickGeometry>(element, "value"); }
private void ExecuteColorType(XmlElement element, MagickSettings settings) { settings.ColorType = Variables.GetValue<ColorType>(element, "value"); }
private void ExecuteSetTransformRotation(XmlElement element, MagickSettings settings) { double angle_ = Variables.GetValue <double>(element, "angle"); settings.SetTransformRotation(angle_); }
private void ExecuteStrokeDashArray(XmlElement element, MagickSettings settings) { settings.StrokeDashArray = Variables.GetDoubleArray(element); }
private void ExecuteStrokeLineJoin(XmlElement element, MagickSettings settings) { settings.StrokeLineJoin = Variables.GetValue<LineJoin>(element, "value"); }
private void ExecuteStrokeMiterLimit(XmlElement element, MagickSettings settings) { settings.StrokeMiterLimit = Variables.GetValue<Int32>(element, "value"); }
private void ExecuteEndian(XmlElement element, MagickSettings settings) { settings.Endian = Variables.GetValue<Endian>(element, "value"); }