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");
}
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);
}
}
