public void GetAdjustedPalette(ColorPalette palette, ColorAdjustType type)
{
// does inplace adjustment
IntPtr memory = palette.ConvertToMemory();
try
{
Gdip.CheckStatus(Gdip.GdipGetImageAttributesAdjustedPalette(
new HandleRef(this, nativeImageAttributes),
memory,
type));
palette.ConvertFromMemory(memory);
}
finally
{
if (memory != IntPtr.Zero)
{
Marshal.FreeHGlobal(memory);
}
}
}
public Image GetThumbnailImage(int thumbWidth, int thumbHeight, Image.GetThumbnailImageAbort callback, IntPtr callbackData)
{
if ((thumbWidth <= 0) || (thumbHeight <= 0))
{
throw new OutOfMemoryException("Invalid thumbnail size");
}
Image ThumbNail = new Bitmap(thumbWidth, thumbHeight);
using (Graphics g = Graphics.FromImage(ThumbNail))
{
int status = Gdip.GdipDrawImageRectRectI(g.NativeGraphics, nativeImage,
0, 0, thumbWidth, thumbHeight,
0, 0, this.Width, this.Height,
GraphicsUnit.Pixel, IntPtr.Zero, null, IntPtr.Zero);
Gdip.CheckStatus(status);
}
return(ThumbNail);
}
public void SetPixel(int x, int y, Color color)
{
if ((PixelFormat & PixelFormat.Indexed) != 0)
{
throw new InvalidOperationException(SR.Format(SR.GdiplusCannotSetPixelFromIndexedPixelFormat));
}
if (x < 0 || x >= Width)
{
throw new ArgumentOutOfRangeException(nameof(x), SR.Format(SR.ValidRangeX));
}
if (y < 0 || y >= Height)
{
throw new ArgumentOutOfRangeException(nameof(y), SR.Format(SR.ValidRangeY));
}
int status = Gdip.GdipBitmapSetPixel(new HandleRef(this, nativeImage), x, y, color.ToArgb());
Gdip.CheckStatus(status);
}
public TextureBrush(Image image, Rectangle dstRect, ImageAttributes imageAttr)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
IntPtr brush = IntPtr.Zero;
int status = Gdip.GdipCreateTextureIAI(new HandleRef(image, image.nativeImage),
new HandleRef(imageAttr, (imageAttr == null) ?
IntPtr.Zero : imageAttr.nativeImageAttributes),
dstRect.X,
dstRect.Y,
dstRect.Width,
dstRect.Height,
out brush);
Gdip.CheckStatus(status);
SetNativeBrushInternal(brush);
}
public TextureBrush(Image image, WrapMode wrapMode)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (wrapMode < WrapMode.Tile || wrapMode > WrapMode.Clamp)
{
throw new InvalidEnumArgumentException(nameof(wrapMode), unchecked ((int)wrapMode), typeof(WrapMode));
}
IntPtr brush = IntPtr.Zero;
int status = Gdip.GdipCreateTexture(new HandleRef(image, image.nativeImage),
(int)wrapMode,
out brush);
Gdip.CheckStatus(status);
SetNativeBrushInternal(brush);
}
internal ColorPalette retrieveGDIPalette()
{
int bytes;
ColorPalette ret = new ColorPalette();
int st = Gdip.GdipGetImagePaletteSize(nativeImage, out bytes);
Gdip.CheckStatus(st);
IntPtr palette_data = Marshal.AllocHGlobal(bytes);
try
{
st = Gdip.GdipGetImagePalette(nativeImage, palette_data, bytes);
Gdip.CheckStatus(st);
ret.ConvertFromMemory(palette_data);
return ret;
}
finally
{
Marshal.FreeHGlobal(palette_data);
}
}
/// <summary>
/// Gets the specified property item from this <see cref='Image'/>.
/// </summary>
public PropertyItem?GetPropertyItem(int propid)
{
Gdip.CheckStatus(Gdip.GdipGetPropertyItemSize(new HandleRef(this, nativeImage), propid, out int size));
if (size == 0)
{
return(null);
}
IntPtr propdata = Marshal.AllocHGlobal(size);
try
{
Gdip.CheckStatus(Gdip.GdipGetPropertyItem(new HandleRef(this, nativeImage), propid, size, propdata));
return(PropertyItemInternal.ConvertFromMemory(propdata, 1)[0]);
}
finally
{
Marshal.FreeHGlobal(propdata);
}
}
/// <summary>
/// Returns the <see cref='MetafileHeader'/> associated with the specified <see cref='Metafile'/>.
/// </summary>
public static MetafileHeader GetMetafileHeader(Stream stream)
{
MetafileHeader header;
IntPtr memory = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MetafileHeaderEmf)));
try
{
using DrawingCom.IStreamWrapper streamWrapper = DrawingCom.GetComWrapper(new GPStream(stream));
Gdip.CheckStatus(Gdip.GdipGetMetafileHeaderFromStream(streamWrapper.Ptr, memory));
int[] type = new int[] { 0 };
Marshal.Copy(memory, type, 0, 1);
MetafileType metafileType = (MetafileType)type[0];
header = new MetafileHeader();
if (metafileType == MetafileType.Wmf ||
metafileType == MetafileType.WmfPlaceable)
{
// WMF header
header.wmf = (MetafileHeaderWmf)Marshal.PtrToStructure(memory, typeof(MetafileHeaderWmf)) !;
header.emf = null;
}
else
{
// EMF header
header.wmf = null;
header.emf = (MetafileHeaderEmf)Marshal.PtrToStructure(memory, typeof(MetafileHeaderEmf)) !;
}
}
finally
{
Marshal.FreeHGlobal(memory);
}
return(header);
}
/// <summary>
/// Returns the <see cref='MetafileHeader'/> associated with the specified <see cref='Metafile'/>.
/// </summary>
public static MetafileHeader GetMetafileHeader(string fileName)
{
// Called in order to emulate exception behavior from netfx related to invalid file paths.
Path.GetFullPath(fileName);
MetafileHeader header = new MetafileHeader();
IntPtr memory = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MetafileHeaderEmf)));
try
{
Gdip.CheckStatus(Gdip.GdipGetMetafileHeaderFromFile(fileName, memory));
int[] type = new int[] { 0 };
Marshal.Copy(memory, type, 0, 1);
MetafileType metafileType = (MetafileType)type[0];
if (metafileType == MetafileType.Wmf ||
metafileType == MetafileType.WmfPlaceable)
{
// WMF header
header.wmf = (MetafileHeaderWmf)Marshal.PtrToStructure(memory, typeof(MetafileHeaderWmf));
header.emf = null;
}
else
{
// EMF header
header.wmf = null;
header.emf = (MetafileHeaderEmf)Marshal.PtrToStructure(memory, typeof(MetafileHeaderEmf));
}
}
finally
{
Marshal.FreeHGlobal(memory);
}
return(header);
}
internal static IntPtr InitFromStream(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
// Unix, with libgdiplus
// We use a custom API for this, because there's no easy way
// to get the Stream down to libgdiplus. So, we wrap the stream
// with a set of delegates.
GdiPlusStreamHelper sh = new GdiPlusStreamHelper(stream, true);
int st = Gdip.GdipLoadImageFromDelegate_linux(sh.GetHeaderDelegate, sh.GetBytesDelegate,
sh.PutBytesDelegate, sh.SeekDelegate, sh.CloseDelegate, sh.SizeDelegate, out IntPtr imagePtr);
// Since we're just passing to native code the delegates inside the wrapper, we need to keep sh alive
// to avoid the object being collected and therefore the delegates would be collected as well.
GC.KeepAlive(sh);
Gdip.CheckStatus(st);
return(imagePtr);
}
// public methods
// static
public static Image FromFile(string filename, bool useEmbeddedColorManagement)
{
IntPtr imagePtr;
int st;
if (!File.Exists(filename))
{
throw new FileNotFoundException(filename);
}
if (useEmbeddedColorManagement)
{
st = Gdip.GdipLoadImageFromFileICM(filename, out imagePtr);
}
else
{
st = Gdip.GdipLoadImageFromFile(filename, out imagePtr);
}
Gdip.CheckStatus(st);
return(CreateFromHandle(imagePtr));
}
public unsafe Bitmap(Stream stream, bool useIcm)
{
ArgumentNullException.ThrowIfNull(stream);
using DrawingCom.IStreamWrapper streamWrapper = DrawingCom.GetComWrapper(new GPStream(stream));
IntPtr bitmap = IntPtr.Zero;
if (useIcm)
{
Gdip.CheckStatus(Gdip.GdipCreateBitmapFromStreamICM(streamWrapper.Ptr, &bitmap));
}
else
{
Gdip.CheckStatus(Gdip.GdipCreateBitmapFromStream(streamWrapper.Ptr, &bitmap));
}
ValidateImage(bitmap);
SetNativeImage(bitmap);
EnsureSave(this, null, stream);
}
public TextureBrush(Image image, WrapMode wrapMode, Rectangle dstRect)
{
ArgumentNullException.ThrowIfNull(image);
if (wrapMode < WrapMode.Tile || wrapMode > WrapMode.Clamp)
{
throw new InvalidEnumArgumentException(nameof(wrapMode), unchecked ((int)wrapMode), typeof(WrapMode));
}
IntPtr brush;
int status = Gdip.GdipCreateTexture2I(new HandleRef(image, image.nativeImage),
unchecked ((int)wrapMode),
dstRect.X,
dstRect.Y,
dstRect.Width,
dstRect.Height,
out brush);
Gdip.CheckStatus(status);
SetNativeBrushInternal(brush);
}
/// <summary>
/// Returns the <see cref='MetafileHeader'/> associated with this <see cref='Metafile'/>.
/// </summary>
public MetafileHeader GetMetafileHeader()
{
MetafileHeader header;
IntPtr memory = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MetafileHeaderEmf)));
try
{
Gdip.CheckStatus(Gdip.GdipGetMetafileHeaderFromMetafile(new HandleRef(this, nativeImage), memory));
int[] type = new int[] { 0 };
Marshal.Copy(memory, type, 0, 1);
MetafileType metafileType = (MetafileType)type[0];
header = new MetafileHeader();
if (metafileType == MetafileType.Wmf ||
metafileType == MetafileType.WmfPlaceable)
{
// WMF header
header.wmf = (MetafileHeaderWmf)Marshal.PtrToStructure(memory, typeof(MetafileHeaderWmf));
header.emf = null;
}
else
{
// EMF header
header.wmf = null;
header.emf = (MetafileHeaderEmf)Marshal.PtrToStructure(memory, typeof(MetafileHeaderEmf));
}
}
finally
{
Marshal.FreeHGlobal(memory);
}
return(header);
}
internal void storeGDIPalette(ColorPalette palette)
{
if (palette == null)
{
throw new ArgumentNullException(nameof(palette));
}
IntPtr palette_data = palette.ConvertToMemory();
if (palette_data == IntPtr.Zero)
{
return;
}
try
{
int st = Gdip.GdipSetImagePalette(nativeImage, palette_data);
Gdip.CheckStatus(st);
}
finally
{
Marshal.FreeHGlobal(palette_data);
}
}
public void SetBlendTriangularShape(float focus, float scale)
{
if (focus < 0 || focus > 1)
{
throw new ArgumentException(SR.Format(SR.GdiplusInvalidParameter), nameof(focus));
}
if (scale < 0 || scale > 1)
{
throw new ArgumentException(SR.Format(SR.GdiplusInvalidParameter), nameof(scale));
}
int status = Gdip.GdipSetLineLinearBlend(new HandleRef(this, NativeBrush), focus, scale);
Gdip.CheckStatus(status);
// Setting a triangular shape overrides the explicitly set interpolation colors. libgdiplus correctly clears
// the interpolation colors (https://github.com/mono/libgdiplus/blob/master/src/lineargradientbrush.c#L959) but
// returns WrongState instead of ArgumentException (https://github.com/mono/libgdiplus/blob/master/src/lineargradientbrush.c#L814)
// when calling GdipGetLinePresetBlend, so it is important we set this to false. This way, we are sure get_InterpolationColors
// will return an ArgumentException.
_interpolationColorsWasSet = false;
}
public void SaveAdd(EncoderParameters encoderParams)
{
IntPtr encoder = IntPtr.Zero;
if (encoderParams != null)
{
encoder = encoderParams.ConvertToMemory();
}
_rawData = null;
try
{
Gdip.CheckStatus(Gdip.GdipSaveAdd(new HandleRef(this, nativeImage), new HandleRef(encoderParams, encoder)));
}
finally
{
if (encoder != IntPtr.Zero)
{
Marshal.FreeHGlobal(encoder);
}
}
}
public Bitmap(string filename, bool useIcm)
{
// GDI+ will read this file multiple times. Get the fully qualified path
// so if the app's default directory changes we won't get an error.
filename = Path.GetFullPath(filename);
IntPtr bitmap = IntPtr.Zero;
int status;
if (useIcm)
{
status = Gdip.GdipCreateBitmapFromFileICM(filename, out bitmap);
}
else
{
status = Gdip.GdipCreateBitmapFromFile(filename, out bitmap);
}
Gdip.CheckStatus(status);
ValidateImage(bitmap);
SetNativeImage(bitmap);
EnsureSave(this, filename, null);
}
/// <summary>
/// Initializes a new instance of the <see cref='FontFamily'/> class from the specified generic font family.
/// </summary>
public FontFamily(GenericFontFamilies genericFamily)
{
IntPtr nativeFamily = IntPtr.Zero;
int status;
switch (genericFamily)
{
case GenericFontFamilies.Serif:
status = Gdip.GdipGetGenericFontFamilySerif(out nativeFamily);
break;
case GenericFontFamilies.SansSerif:
status = Gdip.GdipGetGenericFontFamilySansSerif(out nativeFamily);
break;
case GenericFontFamilies.Monospace:
default:
status = Gdip.GdipGetGenericFontFamilyMonospace(out nativeFamily);
break;
}
Gdip.CheckStatus(status);
SetNativeFamily(nativeFamily);
}
public Bitmap(Type type, string resource)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
Stream?stream = type.Module.Assembly.GetManifestResourceStream(type, resource);
if (stream == null)
{
throw new ArgumentException(SR.Format(SR.ResourceNotFound, type, resource));
}
IntPtr bitmap = IntPtr.Zero;
int status = Gdip.GdipCreateBitmapFromStream(new GPStream(stream), out bitmap);
Gdip.CheckStatus(status);
ValidateImage(bitmap);
SetNativeImage(bitmap);
EnsureSave(this, null, stream);
}
public EncoderParameters GetEncoderParameterList(Guid encoder)
{
int status;
uint sz;
status = Gdip.GdipGetEncoderParameterListSize(nativeImage, ref encoder, out sz);
Gdip.CheckStatus(status);
IntPtr rawEPList = Marshal.AllocHGlobal((int)sz);
EncoderParameters eps;
try
{
status = Gdip.GdipGetEncoderParameterList(nativeImage, ref encoder, sz, rawEPList);
eps = EncoderParameters.ConvertFromMemory(rawEPList);
Gdip.CheckStatus(status);
}
finally
{
Marshal.FreeHGlobal(rawEPList);
}
return(eps);
}
public void Translate(int dx, int dy)
{
Gdip.CheckStatus(Gdip.GdipTranslateRegionI(new HandleRef(this, NativeRegion), dx, dy));
}
public void ResetTransform()
{
Gdip.CheckStatus(Gdip.GdipResetPathGradientTransform(new HandleRef(this, NativeBrush)));
}
public void Exclude(Rectangle rect)
{
Gdip.CheckStatus(Gdip.GdipCombineRegionRectI(new HandleRef(this, NativeRegion), ref rect, CombineMode.Exclude));
}
public void Complement(Rectangle rect)
{
Gdip.CheckStatus(Gdip.GdipCombineRegionRectI(new HandleRef(this, NativeRegion), ref rect, CombineMode.Complement));
}
public void Xor(RectangleF rect)
{
Gdip.CheckStatus(Gdip.GdipCombineRegionRect(new HandleRef(this, NativeRegion), ref rect, CombineMode.Xor));
}
public void MakeEmpty()
{
Gdip.CheckStatus(Gdip.GdipSetEmpty(new HandleRef(this, NativeRegion)));
}
public void MakeInfinite()
{
Gdip.CheckStatus(Gdip.GdipSetInfinite(new HandleRef(this, NativeRegion)));
}
/// <summary>
/// Initializes a new instance of the <see cref='System.Drawing.Text.PrivateFontCollection'/> class.
/// </summary>
public PrivateFontCollection() : base()
{
int status = Gdip.GdipNewPrivateFontCollection(out _nativeFontCollection);
Gdip.CheckStatus(status);
}
/// <summary>
/// Adds a font contained in system memory to this <see cref='System.Drawing.Text.PrivateFontCollection'/>.
/// </summary>
public void AddMemoryFont(IntPtr memory, int length)
{
Gdip.CheckStatus(Gdip.GdipPrivateAddMemoryFont(new HandleRef(this, _nativeFontCollection), memory, length));
}