private static BitmapFrame ConvertFromIcon(Icon icon)
{
var memoryStream = new MemoryStream();
icon.Save(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
return BitmapFrame.Create(memoryStream);
}
Bitmap ExtractVistaIcon(Icon icoIcon)
{
Bitmap bmpPngExtracted = null;
try
{
byte[] srcBuf = null;
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{ icoIcon.Save(stream); srcBuf = stream.ToArray(); }
const int SizeICONDIR = 6;
const int SizeICONDIRENTRY = 16;
int iCount = BitConverter.ToInt16(srcBuf, 4);
for (int iIndex = 0; iIndex < iCount; iIndex++)
{
int iWidth = srcBuf[SizeICONDIR + SizeICONDIRENTRY * iIndex];
int iHeight = srcBuf[SizeICONDIR + SizeICONDIRENTRY * iIndex + 1];
int iBitCount = BitConverter.ToInt16(srcBuf, SizeICONDIR + SizeICONDIRENTRY * iIndex + 6);
if (iWidth == 0 && iHeight == 0 && iBitCount == 32)
{
int iImageSize = BitConverter.ToInt32(srcBuf, SizeICONDIR + SizeICONDIRENTRY * iIndex + 8);
int iImageOffset = BitConverter.ToInt32(srcBuf, SizeICONDIR + SizeICONDIRENTRY * iIndex + 12);
System.IO.MemoryStream destStream = new System.IO.MemoryStream();
System.IO.BinaryWriter writer = new System.IO.BinaryWriter(destStream);
writer.Write(srcBuf, iImageOffset, iImageSize);
destStream.Seek(0, System.IO.SeekOrigin.Begin);
bmpPngExtracted = new Bitmap(destStream); // This is PNG! :)
break;
}
}
}
catch { return null; }
return bmpPngExtracted;
}
private static ImageSource ToImageSource(System.Drawing.Icon icon)
{
using var ms = new MemoryStream();
icon.Save(ms);
ms.Position = 0;
return(BitmapFrame.Create(ms, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad));
}
private void btn_Manually_Click(object sender, EventArgs e)
{
using (OpenFileDialog open = new OpenFileDialog())
{
open.Filter = "Game Executable|*.exe";
if (open.ShowDialog() == DialogResult.OK)
{
string path = open.FileName;
Bitmap icon;
string key = Path.GetDirectoryName(path);
if (!imageList1.Images.ContainsKey(key))
{
using (System.Drawing.Icon sysicon = Icon.ExtractAssociatedIcon(path))
{
using (MemoryStream str = new MemoryStream())
{
sysicon.Save(str);
str.Position = 0;
icon = (Bitmap)Image.FromStream(str);
}
}
this.imageList1.Images.Add(key, icon);
}
ListViewItem item = new ListViewItem(open.FileName, key);
this.list_Games.Items.Add(item);
}
}
}
public static byte[] IconToBytes(Icon icon)
{
using (var ms = new MemoryStream())
{
icon.Save(ms);
return ms.ToArray();
}
}
private byte[] GetIconBytes(Icon icon)
{
using (var ms = new MemoryStream())
{
icon.Save(ms);
ms.Flush();
return ms.GetBuffer();
}
}
public static void ShowNotify(string header, string content, NotifyDuration duration = NotifyDuration.Long,
TypedEventHandler <ToastNotification, object> activateFunc = null,
TypedEventHandler <ToastNotification, ToastDismissedEventArgs> dismissFunc = null,
TypedEventHandler <ToastNotification, ToastFailedEventArgs> failFunc = null, string iconPath = "", string APP_ID = "")
{
ComponentResourceManager resources = new ComponentResourceManager(typeof(frmMain));
System.Drawing.Icon icon = (System.Drawing.Icon)resources.GetObject("$this.Icon");
string filepath = Path.Combine(Environment.ExpandEnvironmentVariables(@"%AppData%"), "FoBots");
Directory.CreateDirectory(filepath);
if (!File.Exists(Path.Combine(filepath, "icon.ico")))
{
FileStream outStream = File.Create(Path.Combine(filepath, "icon.ico"));
icon.Save(outStream);
outStream.Flush();
outStream.Close();
}
iconPath = Path.Combine(filepath, "icon.ico");
ToastTemplateType toastTemplate = ToastTemplateType.ToastImageAndText02;
XmlDocument toastXml = ToastNotificationManager.GetTemplateContent(toastTemplate);
XmlNodeList toastTextElements = toastXml.GetElementsByTagName("text");
toastTextElements[0].AppendChild(toastXml.CreateTextNode(header));
toastTextElements[1].AppendChild(toastXml.CreateTextNode(content));
XmlNodeList toastImageElements = toastXml.GetElementsByTagName("image");
((XmlElement)toastImageElements[0]).SetAttribute("src", iconPath);
IXmlNode toastNode = toastXml.SelectSingleNode("/toast");
((XmlElement)toastNode).SetAttribute("duration", Enum.GetName(typeof(NotifyDuration), duration));
ToastNotification toast = new ToastNotification(toastXml);
toast.Activated += activateFunc ?? ToastActivated;
toast.Dismissed += dismissFunc ?? ToastDismissed;
toast.Failed += failFunc ?? ToastFailed;
try
{
if (TryCreateShortcut(APP_ID))
{
ToastNotificationManager.CreateToastNotifier(APP_ID + NotID).Show(toast);
}
}
catch (Exception ex)
{
NLog.LogManager.Flush();
var attachments = new ErrorAttachmentLog[] { ErrorAttachmentLog.AttachmentWithText(File.ReadAllText("log.foblog"), "log.foblog") };
var properties = new Dictionary <string, string> {
{ "ShowNotify", i18n.getString("ShowingNotify") }
};
Crashes.TrackError(ex, properties, attachments);
}
}
public IconHandler(sd.Icon icon)
{
var rect = new sw.Int32Rect(0, 0, icon.Width, icon.Height);
var img = swi.Imaging.CreateBitmapSourceFromHIcon(icon.Handle, rect, swmi.BitmapSizeOptions.FromEmptyOptions());
Control = swmi.BitmapFrame.Create(img);
using (var ms = new MemoryStream())
{
icon.Save(ms);
ms.Position = 0;
SetFrames(ms);
}
}
private static Bitmap ExtractVistaIcon(Icon icon)
{
Bitmap extractedIcon = null;
if (icon == null)
{
return extractedIcon;
}
try
{
byte[] srcBuf = null;
using (var stream = new MemoryStream())
{
icon.Save(stream);
srcBuf = stream.ToArray();
}
const int SizeICONDIR = 6;
const int SizeICONDIRENTRY = 16;
int iCount = BitConverter.ToInt16(srcBuf, 4);
for (int iIndex = 0; iIndex < iCount; iIndex++)
{
int width = srcBuf[SizeICONDIR + SizeICONDIRENTRY * iIndex];
int height = srcBuf[SizeICONDIR + SizeICONDIRENTRY * iIndex + 1];
int bitCount = BitConverter.ToInt16(srcBuf, SizeICONDIR + SizeICONDIRENTRY * iIndex + 6);
if (width == 0 && height == 0 && bitCount == 32)
{
int imageSize = BitConverter.ToInt32(srcBuf, SizeICONDIR + SizeICONDIRENTRY * iIndex + 8);
int imageOffset = BitConverter.ToInt32(srcBuf, SizeICONDIR + SizeICONDIRENTRY * iIndex + 12);
using (var destStream = new MemoryStream())
{
var writer = new BinaryWriter(destStream);
writer.Write(srcBuf, imageOffset, imageSize);
destStream.Seek(0, SeekOrigin.Begin);
extractedIcon = new Bitmap(destStream); // This is PNG! :)
return extractedIcon;
}
}
}
}
catch
{
return null;
}
return extractedIcon;
}
/// <summary>
/// Converts the specified icon into a bitmap
/// </summary>
/// <param name="icon">icon to convert</param>
/// <returns>bitmap representation of icon</returns>
public static Bitmap ConvertIconToBitmap(Icon icon)
{
if (icon != null)
{
using (var memoryStream = new MemoryStream())
{
icon.Save(memoryStream);
using (var bitmap = (Bitmap)Image.FromStream(memoryStream))
{
return new Bitmap(bitmap);
}
}
}
return null;
}
public string IconToBytes(Icon icon)
{
try
{
using (MemoryStream ms = new MemoryStream())
{
icon.Save(ms);
byte[] bytes = ms.ToArray();
return Convert.ToBase64String(bytes);
}
}
catch (Exception e)
{
return "";
}
}
public static BitmapImage IconToBitmapImage(System.Drawing.Icon ico)
{
MemoryStream ms = new MemoryStream();
ico.Save(ms);
BitmapImage bImg = new System.Windows.Media.Imaging.BitmapImage();
bImg.BeginInit();
bImg.StreamSource = new MemoryStream(ms.ToArray());
bImg.CreateOptions = BitmapCreateOptions.None;
bImg.CacheOption = BitmapCacheOption.Default;
bImg.EndInit();
ms.Close();
return(bImg);
}
private void btnSaveIcon_Click(object sender, EventArgs e)
{
if (picSource.Image != null)
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Title = "Specify a file name and file path";
sfd.Filter = "Icon Files(*.ico)|*.ico";
if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
System.Drawing.Icon tempIcon = ((Bitmap)picSource.Image).CreateIcon(
(IconSizeDimensions)cmbIconSize.SelectedItem);
using (StreamWriter streamWriter = new StreamWriter(sfd.FileName, false))
{
tempIcon.Save(streamWriter.BaseStream);
streamWriter.Flush();
streamWriter.Close();
}
}
}
}
private void SavePicture(string S_Name)
{
string[] arry = S_Name.Split('.');
Bitmap Bmp = new Bitmap((Bitmap)Image.FromFile(textBox1.Text + "\\" + S_Name), int.Parse(textBox3.Text), int.Parse(textBox4.Text));
string SaveName = textBox2.Text + "\\";
IfNotFileCreat(SaveName);
SaveName += (arry[0] + "." + SaveType);
switch (SaveType)
{
case "Png": Bmp.Save(SaveName, ImageFormat.Png); break;
case "Ico": Bmp.Save(SaveName, ImageFormat.Icon);
System.Drawing.Icon icon = System.Drawing.Icon.FromHandle(Bmp.GetHicon());
System.IO.FileStream fileStream = new System.IO.FileStream(SaveName, System.IO.FileMode.Create);
icon.Save(fileStream);
Bmp.Dispose();
fileStream.Close();
fileStream.Dispose();
icon.Dispose();
break;
case "Emf": Bmp.Save(SaveName, ImageFormat.Emf); break;
case "Jpg": Bmp.Save(SaveName, ImageFormat.Jpeg); break;
case "Wmf": Bmp.Save(SaveName, ImageFormat.Wmf); break;
case "Gif": Bmp.Save(SaveName, ImageFormat.Gif); break;
case "Exif": Bmp.Save(SaveName, ImageFormat.Exif); break;
case "Bmp": Bmp.Save(SaveName, ImageFormat.Bmp); break;
default: break;
}
}
public static AddinInstallerFile Build(string license, List<string> dependencies, string assembly, Icon icon)
{
var ret = new AddinInstallerFile();
ret.License = license;
if (icon != null)
{
var ims = new MemoryStream();
icon.Save(ims);
ret.Icon = ims.ToArray();
}
if (dependencies != null)
{
foreach (var dependency in dependencies)
{
ret.Dependecies.Add(Path.GetFileName(dependency), File.ReadAllBytes(dependency));
}
}
ret.Assembly = new KeyValuePair<string, byte[]>(Path.GetFileName(assembly), File.ReadAllBytes(assembly));
return ret;
}
internal static void SaveAndCompare (string msg, Icon icon, bool alpha)
{
using (MemoryStream ms = new MemoryStream ()) {
icon.Save (ms);
ms.Position = 0;
using (Icon loaded = new Icon (ms)) {
Assert.AreEqual (icon.Height, loaded.Height, msg + ".Loaded.Height");
Assert.AreEqual (icon.Width, loaded.Width, msg + ".Loaded.Width");
using (Bitmap expected = icon.ToBitmap ()) {
using (Bitmap actual = loaded.ToBitmap ()) {
Assert.AreEqual (expected.Height, actual.Height, msg + ".Bitmap.Height");
Assert.AreEqual (expected.Width, actual.Width, msg + ".Bitmap.Width");
for (int y = 0; y < expected.Height; y++) {
for (int x = 0; x < expected.Width; x++) {
Color e = expected.GetPixel (x, y);
Color a = actual.GetPixel (x, y);
if (alpha)
Assert.AreEqual (e.A, a.A, String.Format ("{0}:{1}x{2}:A", msg, x, y));
Assert.AreEqual (e.R, a.R, String.Format ("{0}:{1}x{2}:R", msg, x, y));
Assert.AreEqual (e.G, a.G, String.Format ("{0}:{1}x{2}:G", msg, x, y));
Assert.AreEqual (e.B, a.B, String.Format ("{0}:{1}x{2}:B", msg, x, y));
}
}
}
}
}
}
}
/// <summary>
/// convert Icon to base64 string </summary>
public static string IconToString(Icon icon)
{
try
{
using (MemoryStream ms = new MemoryStream())
{
icon.Save(ms);
byte[] bytes = ms.ToArray();
return Convert.ToBase64String(bytes);
}
}
catch (Exception e)
{
Program.log.write("IconToString error: " + e.Message);
return "";
}
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == null)
{
throw new ArgumentNullException("destinationType");
}
if (destinationType == typeof(Image) || destinationType == typeof(Bitmap))
{
Icon icon = value as Icon;
if (icon != null)
{
return(icon.ToBitmap());
}
}
if (destinationType == typeof(string))
{
if (value != null)
{
return(value.ToString());
}
else
{
return(SR.GetString(SR.toStringNone));
}
}
if (destinationType == typeof(byte[]))
{
if (value != null)
{
MemoryStream ms = null;
try {
ms = new MemoryStream();
Icon icon = value as Icon;
if (icon != null)
{
icon.Save(ms);
}
}
finally {
if (ms != null)
{
ms.Close();
}
}
if (ms != null)
{
return(ms.ToArray());
}
else
{
return(null);
}
}
else
{
return(new byte[0]);
}
}
return(base.ConvertTo(context, culture, value, destinationType));
}
private void CreateIcon(string path, bool useDefault = true) {
var str = Legacy.UserSettings.ImageDir + @"\" + g.FileSafeTitle + ".ico";
if (useDefault) {
using (var stream = new FileStream(str, FileMode.OpenOrCreate, FileAccess.ReadWrite)) {
Properties.Resources.icon.Save(stream);
return;
}
}
var icon = new Icon(path);
using (var stream2 = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite)) {
icon.Save(stream2);
icon.Dispose();
}
}
private void CreateIcon(String name, Icon icon)
{
using (Stream iconStream = new FileStream(name, FileMode.Create))
{
icon.Save(iconStream);
}
icon.Dispose();
}
private int SaveStreamResource(string resName, Stream s, string saveDir)
{
if (s == null)
return 0;
int count = 0;
bool handled = false;
string outputFile = GetOutputResourceFile(resName, saveDir);
if (PathUtils.IsIconExt(outputFile))
{
try
{
if (s.CanSeek)
s.Seek(0, SeekOrigin.Begin);
Icon ico = new Icon(s);
using (FileStream fs = File.Create(outputFile))
{
ico.Save(fs);
}
count++;
handled = true;
}
catch (ArgumentException) { }
}
else if (PathUtils.IsCursorExt(outputFile))
{
try
{
//it seems there is no easy way to write cursor to file
//http://msdn.microsoft.com/en-us/library/ms997538.aspx
Cursor c = LoadCursor(s);
Bitmap bmp = ConvertToBitmap(c);
bmp.Save(outputFile + GetImageExt(bmp));
count++;
handled = true;
}
catch (Exception ex)
{
_form.SetStatusText(String.Format("Failed to save {0}: {1}", resName, ex.Message));
}
}
else if (ResourceFile.Default.IsImageResource(outputFile))
{
try
{
Bitmap bmp = new Bitmap(s);
bmp.Save(outputFile);
count++;
handled = true;
}
catch (ArgumentException) { }
}
else if (PathUtils.IsBamlExt(outputFile))
{
try
{
string newOutputFile = Path.ChangeExtension(outputFile, ".xaml");
using (StreamWriter sw = File.CreateText(newOutputFile))
{
sw.WriteLine(DecompileBaml(s));
}
count++;
//handled = true;
}
catch (Exception ex)
{
_form.SetStatusText(String.Format("Failed to translate {0}: {1}", resName, ex.Message));
}
}
if (!handled)
{
byte[] buffer = new byte[s.Length];
if (s.CanSeek)
{
s.Seek(0, SeekOrigin.Begin);
}
s.Read(buffer, 0, buffer.Length);
using (FileStream fs = File.Create(outputFile))
{
fs.Write(buffer, 0, buffer.Length);
}
count++;
}
return count;
}
[Test] // bug #410608
public void Save_256 ()
{
string filepath = TestBitmap.getInFile ("bitmaps/323511.ico");
using (Icon icon = new Icon (filepath)) {
// bug #415809 fixed
SaveAndCompare ("256", icon, true);
}
// binary comparison
var orig = new MemoryStream (File.ReadAllBytes (filepath));
var saved = new MemoryStream ();
using (Icon icon = new Icon (filepath))
icon.Save (saved);
FileAssert.AreEqual (orig, saved, "binary comparison");
}
private int GetIconBitDepth(Icon icon)
{
if (icon == null)
{
throw new ArgumentNullException("icon");
}
byte[] data = null;
using (MemoryStream stream = new MemoryStream())
{
icon.Save(stream);
data = stream.ToArray();
}
return BitConverter.ToInt16(data, 12);
}
public static Bitmap ToBitmap(this Icon icon, int maxWidth, int maxHeight = -1,
int maxDepth = 32, int minWidth = 1, int minHeight = -1, int minDepth = 1)
{
int matchingIndex = -1;
int matchingWidth = 0;
int matchingHeight = 0;
int matchingDepth = 0;
if (maxHeight < 0)
{
maxHeight = maxWidth;
}
if (minHeight < 0)
{
minHeight = minWidth;
}
byte[] srcBuf = null;
using (MemoryStream readStream = new MemoryStream())
{ icon.Save(readStream); srcBuf = readStream.ToArray(); }
const int SizeICONDIR = 6;
const int SizeICONDIRENTRY = 16;
int iCount = BitConverter.ToInt16(srcBuf, 4);
for (int iIndex = 0; iIndex < iCount; iIndex++)
{
int iWidth = srcBuf[SizeICONDIR + SizeICONDIRENTRY * iIndex];
int iHeight = srcBuf[SizeICONDIR + SizeICONDIRENTRY * iIndex + 1];
if (iWidth == 0)
{
iWidth = 256;
}
if (iHeight == 0)
{
iHeight = 256;
}
var iBitCount = BitConverter.ToInt16(srcBuf, SizeICONDIR + SizeICONDIRENTRY * iIndex + 6);
if (iWidth < minWidth || iWidth > maxWidth ||
iHeight < minHeight || iHeight > maxHeight ||
iBitCount < minDepth || iBitCount > maxDepth)
{
continue;
}
if (iWidth >= matchingWidth && iHeight >= matchingHeight && iBitCount >= matchingDepth)
{
matchingIndex = iIndex;
matchingWidth = iWidth;
matchingHeight = iHeight;
matchingDepth = iBitCount;
if (matchingWidth == maxWidth && matchingHeight == maxHeight && matchingDepth == maxDepth)
{
break;
}
}
}
if (matchingIndex < 0)
{
return(null);
}
int iImageSize = BitConverter.ToInt32(srcBuf, SizeICONDIR + SizeICONDIRENTRY * matchingIndex + 8);
int iImageOffset = BitConverter.ToInt32(srcBuf, SizeICONDIR + SizeICONDIRENTRY * matchingIndex + 12);
var magic = Encoding.ASCII.GetString(srcBuf, iImageOffset + 1, 3);
if (magic == "PNG")
{
// Bitmap class reads any PNG directly from stream
var stream = new MemoryStream();
var writer = new BinaryWriter(stream);
writer.Write(srcBuf, iImageOffset, iImageSize);
stream.Seek(0, SeekOrigin.Begin);
return(new Bitmap(stream));
}
else
{
// BMP format, determine metadata
const int BI_BITFIELDS = 3;
const int BI_ALPHABITFIELDS = 6;
int numColors = srcBuf[SizeICONDIR + SizeICONDIRENTRY * matchingIndex + 2];
if (numColors == 0 && matchingDepth <= 8)
{
numColors = 1 << matchingDepth;
}
int headerSize = BitConverter.ToInt32(srcBuf, iImageOffset);
int compressionMethod = BitConverter.ToInt32(srcBuf, iImageOffset + 30);
int pixelDataOffset = headerSize + numColors * (headerSize == 12 ? 3 : 4);
if (compressionMethod == BI_BITFIELDS)
{
pixelDataOffset += 12;
}
if (compressionMethod == BI_ALPHABITFIELDS)
{
pixelDataOffset += 16;
}
if (matchingDepth == 32)
{
// BMP with 32 bits not directly supported, load pixels ourselves
unsafe
{
fixed(byte *srcBufPtr = srcBuf)
{
var pixels = srcBufPtr + iImageOffset + pixelDataOffset;
var result = new Bitmap(matchingWidth, matchingHeight, PixelFormat.Format32bppArgb);
var resultBits = result.LockBits(new Rectangle(0, 0, result.Width, result.Height),
ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
byte *dest = (byte *)resultBits.Scan0;
for (int y = matchingHeight - 1; y >= 0; --y)
{
byte *src = pixels + y * resultBits.Stride;
for (int i = resultBits.Stride; i > 0; --i)
{
*dest++ = *src++;
}
}
result.UnlockBits(resultBits);
return(result);
}
}
}
else
{
bool upsideDown;
// Add size of BITMAPFILEHEADER
pixelDataOffset += 14;
// Fix DIB header info
if (headerSize == 12)
{
// BITMAPCOREHEADER
upsideDown = BitConverter.ToInt16(srcBuf, iImageOffset + 6) >= 0;
var w16 = Convert.ToInt16(matchingWidth);
var h16 = Convert.ToInt16(matchingHeight);
BitConverter.GetBytes(w16).CopyTo(srcBuf, iImageOffset + 4);
BitConverter.GetBytes(h16).CopyTo(srcBuf, iImageOffset + 6);
BitConverter.GetBytes(matchingDepth).CopyTo(srcBuf, iImageOffset + 10);
}
else
{
// BITMAPINFOHEADER
upsideDown = BitConverter.ToInt32(srcBuf, iImageOffset + 8) >= 0;
BitConverter.GetBytes(matchingWidth).CopyTo(srcBuf, iImageOffset + 4);
BitConverter.GetBytes(matchingHeight).CopyTo(srcBuf, iImageOffset + 8);
BitConverter.GetBytes(matchingDepth).CopyTo(srcBuf, iImageOffset + 14);
}
Bitmap result;
using (var stream = new MemoryStream())
{
var writer = new BinaryWriter(stream);
// Write BITMAPFILEHEADER
writer.Write(Encoding.ASCII.GetBytes("BM"));
writer.Write(iImageSize + 14);
writer.Write(0);
writer.Write(pixelDataOffset);
writer.Write(srcBuf, iImageOffset, iImageSize);
stream.Seek(0, SeekOrigin.Begin);
var tmp = new Bitmap(stream);
result = new Bitmap(tmp.Width, tmp.Height, PixelFormat.Format32bppArgb);
using (var g = Graphics.FromImage(result))
{
g.DrawImage(tmp, 0, 0);
}
}
int srcStride = matchingWidth * matchingDepth / 8;
int srcStrideModulus = srcStride % 4;
if (srcStrideModulus != 0)
{
srcStride += 4 - srcStrideModulus;
}
var resultBits = result.LockBits(new Rectangle(0, 0, result.Width, result.Height),
ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
int extraBits = 32 - matchingWidth % 32;
if (extraBits == 32)
{
extraBits = 0;
}
int skipBytes = extraBits / 8;
if (extraBits % 8 != 0)
{
++skipBytes;
}
unsafe
{
fixed(byte *srcBufPtr = srcBuf)
{
byte *andMask = srcBufPtr + iImageOffset + pixelDataOffset - 14 + matchingHeight * srcStride;
int bitmask = 1 << 7;
for (int y = 0; y < matchingHeight; ++y)
{
byte *outLine = (byte *)resultBits.Scan0;
if (upsideDown)
{
outLine += (matchingHeight - 1 - y) * resultBits.Stride;
}
else
{
outLine += y * resultBits.Stride;
}
for (byte *outAlpha = outLine + 3; outAlpha < outLine + 4 * matchingWidth; outAlpha += 4)
{
if ((*andMask & bitmask) > 0)
{
*outAlpha = 0;
}
bitmask >>= 1;
if (bitmask == 0)
{
bitmask = 1 << 7;
++andMask;
}
}
if (extraBits > 0)
{
bitmask = 1 << 7;
andMask += skipBytes;
}
}
}
}
result.UnlockBits(resultBits);
return(result);
}
}
}
public static byte[] GetBytes(Icon icon)
{
if (icon == null)
return new byte[0];
System.IO.MemoryStream stream = new System.IO.MemoryStream();
icon.Save(stream);
return stream.GetBuffer();
}
private static byte[] GetIconData(Icon ico)
{
var ms = new MemoryStream();
ico.Save(ms);
return ms.ToArray();
}
private static byte[] GetIconData(Icon icon)
{
var data = IconDataDelegate(icon);
if (data != null)
{
return data;
}
using (var ms = new MemoryStream())
{
icon.Save(ms);
return ms.ToArray();
}
}
[Test] // bug #410608
public void Save_256 ()
{
if (RunningOnUnix)
Assert.Ignore ("Depends on bug #323511");
using (Icon icon = new Icon (TestBitmap.getInFile ("bitmaps/323511.ico"))) {
// FIXME: use this instead after bug #415809 is fixed
//SaveAndCompare ("256", icon, true);
MemoryStream ms = new MemoryStream ();
icon.Save (ms);
ms.Position = 0;
using (Icon loaded = new Icon (ms)) {
Assert.AreEqual (icon.Height, loaded.Height, "Loaded.Height");
Assert.AreEqual (icon.Width, loaded.Width, "Loaded.Width");
}
}
}
public static void SaveIcon(Icon SourceIcon, string IconFilename)
{
FileStream NewIconStream = new FileStream(IconFilename, FileMode.Create);
SourceIcon.Save(NewIconStream);
NewIconStream.Close();
}
private void SaveIcon(Icon icon)
{
if (saveFileDialog1.ShowDialog(this) == DialogResult.OK)
{
FileStream fs = File.Create(saveFileDialog1.FileName);
icon.Save(fs);
fs.Close();
}
}
//internal static Bitmap CreateDisabledBitmap(Bitmap bmp)
//{
// if(bmp==null)
// return null;
// Bitmap bmpTarget=null;
// try
// {
// int nWidth = bmp.Width;
// int nHeight = bmp.Height;
// bmpTarget = new Bitmap(bmp);
// for (int iX = 0; iX < nWidth; iX++)
// {
// for (int iY = 0; iY < nHeight; iY++)
// {
// Color cr = bmp.GetPixel(iX, iY);
// if(cr.IsEmpty || cr==Color.Transparent)
// {
// bmpTarget.SetPixel(iX, iY, Color.Transparent);
// }
// else
// {
// byte nA = cr.A;
// byte nB = (byte) ((cr.B + 255) / 2);
// byte nG = (byte) ((cr.G + 255) / 2);
// byte nR = (byte) ((cr.R + 255) / 2);
// nR = nG = nB = (byte) (nR * 0.299 + nG * 0.587 + nB * 0.114);
// bmpTarget.SetPixel(iX, iY, Color.FromArgb(nA, nR, nG, nB));
// }
// }
// }
// }
// catch
// {
// return null;
// }
// return bmpTarget;
//}
internal static Icon CreateDisabledIcon(Icon ico)
{
try
{
System.IO.MemoryStream memStream = new System.IO.MemoryStream();
ico.Save(memStream);
byte[] array = memStream.ToArray();
int nIconCount = array[4];
for (int iIcon = 0; iIcon < nIconCount; iIcon++)
{
int nBaseOffset = 6 + iIcon * 16;
int nWidth = array[nBaseOffset + 0];
int nHeight = array[nBaseOffset + 1];
int nOffset = GetDWORD(ref array, nBaseOffset + 12);
//data at position
int nStructSize = GetDWORD(ref array, nOffset);
int nPlanes = GetWORD(ref array, nOffset + 12);
int nBitCount = GetWORD(ref array, nOffset + 14);
//process 32-bit Icons (bitcount=32)
//process 24-bit icons (bitcount=24)
//process 8-bit (256 color) icons (bitcount=8)
if (nPlanes != 1) continue;
int nSize = GetDWORD(ref array, nOffset + 20);
int nStep = 0;
switch (nBitCount)
{
case 32: nStep = 4; nSize = nWidth * nHeight * 4; break;
case 24: nStep = 3; nSize = nWidth * nHeight * 3; break;
case 8: nStep = 4; nSize = 1024; break; //256 colors x 4 bytes
default: continue;
}
int iDataStart = nOffset + nStructSize;
for (int iPtr = iDataStart; iPtr < iDataStart + nSize; iPtr += nStep)
{
byte nB = (byte)((array[iPtr] + 255) / 2);
byte nG = (byte)((array[iPtr + 1] + 255) / 2);
byte nR = (byte)((array[iPtr + 2] + 255) / 2);
if (!(nB == 127 && nG == 127 && nR == 127))
{
byte nNewRGB = (byte)(nR * 0.299 + nG * 0.587 + nB * 0.114);
array[iPtr] = nNewRGB;
array[iPtr + 1] = nNewRGB;
array[iPtr + 2] = nNewRGB;
}
}
}
return new Icon(new System.IO.MemoryStream(array));
}
catch (Exception)
{
return null;
}
}
/// <summary>
/// Converts an Icon to a GDI+ Bitmap preserving the transparent area.
/// </summary>
/// <param name="icon">An System.Drawing.Icon to be converted.</param>
/// <returns>A System.Drawing.Bitmap Object.</returns>
public static Bitmap ToBitmap(Icon icon)
{
if (icon == null)
throw new ArgumentNullException(nameof(icon));
// Quick workaround: Create an .ico file in memory, then load it as a Bitmap.
using (var ms = new MemoryStream())
{
icon.Save(ms);
using (var bmp = (Bitmap) Image.FromStream(ms))
{
return new Bitmap(bmp);
}
}
}
/// <summary>
/// Gets an icon of a specific size from a set of icons.
/// </summary>
/// <param name="icon">The icon.</param>
/// <param name="size">The size required.</param>
/// <returns>The icon that is cloest to the size provided.</returns>
protected static Icon GetIconSpecificSize(Icon icon, Size size)
{
// Create a memory stream.
using (var memoryStream = new MemoryStream())
{
// Save the icon to the stream, then seek to the origin.
icon.Save(memoryStream);
memoryStream.Position = 0;
// Load the icon from the stream, but specify the size.
return new Icon(memoryStream, size);
}
}
/// <summary>
/// Converts an Icon to a Bitmap
/// </summary>
/// <param name="icon">The Icon to be converted</param>
/// <returns>A Bitmap that contains the converted Icon</returns>
internal static unsafe Bitmap ConvertToBitmap(Icon icon)
{
Bitmap bitmap = null;
// get the screen bpp
int bitDepth = 0;
IntPtr dc = NativeMethods.GetDC(IntPtr.Zero);
bitDepth = NativeMethods.GetDeviceCaps(dc, 12 /*BITSPIXEL*/);
bitDepth *= NativeMethods.GetDeviceCaps(dc, 14 /*PLANES*/);
NativeMethods.ReleaseDC(IntPtr.Zero, dc);
// if the screen bpp is not 32bpp return the
// null bitmap so that IconToBitmap can get
// windows to convert the icon (as it only
// ignores the alpha channel if the display
// is in 32bpp mode - why??)
if (bitDepth != 32)
{
return bitmap;
}
// get the default icon sizes
int defaultWidth = NativeMethods.GetSystemMetrics(11 /*SM_CXICON*/);
int defaultHeight = NativeMethods.GetSystemMetrics(12 /*SM_CYICON*/);
// convert the icon into a byte array
MemoryStream ms = new MemoryStream();
icon.Save(ms);
byte[] iconData = ms.ToArray();
ms.Close();
ms = null;
// prevent the garbage collector from relocating the iconData
fixed (byte* data = iconData)
{
// "read" the data
ICONFILE* iconfile = (ICONFILE*)data;
// make sure we have valid data
if (iconfile->reserved != 0 || iconfile->resourceType != 1 || iconfile->iconCount == 0)
{
throw new ArgumentException("The argument picture must be a picture that can be used as a Icon");
}
// set the current entry to the start of the entry section
ICONENTRY* currentEntry = &iconfile->entries;
// the entry that contains the icon whose properties closest
// match the default icon size and bitdepth
ICONENTRY* targetEntry = null;
int bpp = 0;
// record the size of an ICONENTRY
int iconEntrySize = Marshal.SizeOf(typeof(ICONENTRY));
// make sure we have enough data to read each entry
if ((iconEntrySize * iconfile->iconCount) >= iconData.Length)
{
throw new ArgumentException("The argument picture must be a picture that can be used as a Icon");
}
// go through each entry
for (int i = 0; i < iconfile->iconCount; i++)
{
// get the icons bpp
int iconBitDepth = currentEntry->numPlanes * currentEntry->bitsPerPixel;
// make sure it is at least 16bpp
iconBitDepth = Math.Max(iconBitDepth, 16);
// set the target entry if we haven't already
if (targetEntry == null)
{
targetEntry = currentEntry;
bpp = iconBitDepth;
}
else
{
// work out the difference between default sizes
int targetTotalDiff = Math.Abs(targetEntry->width - defaultWidth) + Math.Abs(targetEntry->height - defaultHeight);
int currentTotalDiff = Math.Abs(currentEntry->width - defaultWidth) + Math.Abs(currentEntry->height - defaultHeight);
// check if the current match is closer than the previous match
if (currentTotalDiff < targetTotalDiff)
{
targetEntry = currentEntry;
bpp = iconBitDepth;
}
// if the size differences are the same, compare bit depths
else if ((currentTotalDiff == targetTotalDiff) && ((iconBitDepth <= bitDepth) && (iconBitDepth > bpp)) || (bpp > bitDepth) && (iconBitDepth < bpp))
{
targetEntry = currentEntry;
bpp = iconBitDepth;
}
}
// move to the next entry
currentEntry++;
}
// make sure the target entry is valid
if ((targetEntry->dataOffset < 0) || ((targetEntry->dataOffset + targetEntry->dataSize) > iconData.Length))
{
throw new ArgumentException("The argument picture must be a picture that can be used as a Icon");
}
// make sure the target is 32bpp
if (targetEntry->bitsPerPixel == 32)
{
int offset = targetEntry->dataOffset;
int dataSize = targetEntry->dataSize;
bitmap = new Bitmap(targetEntry->width, targetEntry->height, PixelFormat.Format32bppArgb);
int FILE_HEADER_BYTES = 40;
int PALETTE_SIZE = targetEntry->bitsPerPixel * 4;
int AND_MAP_SIZE = (targetEntry->width / 8) * (targetEntry->height / 8);
int XOR_MAP_SIZE = dataSize - FILE_HEADER_BYTES - PALETTE_SIZE;
int ROW_SIZE = targetEntry->width * (targetEntry->bitsPerPixel / 8);
byte[] bitmapBytes = new byte[dataSize];
GCHandle gcHandle = GCHandle.Alloc(bitmapBytes, GCHandleType.Pinned);
// nb. we only copy the actual PNG data (no header)
Array.Copy(iconData, offset, bitmapBytes, 0, dataSize);
// copy the byte array contents back to a handle to the alpha bitmap (use lockbits)
Rectangle copyArea = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
BitmapData alphaBits = bitmap.LockBits(copyArea, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
int dataStart = FILE_HEADER_BYTES + PALETTE_SIZE;
// copymemory to bitmap data (Scan0)
IntPtr firstCopyElement = Marshal.UnsafeAddrOfPinnedArrayElement(bitmapBytes, dataStart);
NativeMethods.CopyMemory(alphaBits.Scan0, firstCopyElement, XOR_MAP_SIZE - ROW_SIZE);
gcHandle.Free();
// complete operation
bitmap.UnlockBits(alphaBits);
NativeMethods.GdiFlush();
// flip bits (not sure why this is needed at the moment..)
bitmap.RotateFlip(RotateFlipType.Rotate180FlipX);
}
}
return bitmap;
}
/// <summary>
/// Split an Icon consists of multiple icons into an array of Icon each consist of single icons.
/// </summary>
/// <param name="icon">The System.Drawing.Icon to be split.</param>
/// <returns>An array of System.Drawing.Icon each consist of single icons.</returns>
public static Icon[] SplitIcon(Icon icon)
{
if (icon == null)
{
throw new ArgumentNullException("icon");
}
// Get multiple .ico file image.
byte[] srcBuf = null;
using (MemoryStream stream = new MemoryStream())
{
icon.Save(stream);
srcBuf = stream.ToArray();
}
List<Icon> splitIcons = new List<Icon>();
{
int count = BitConverter.ToInt16(srcBuf, 4); // ICONDIR.idCount
for (int i = 0; i < count; i++)
{
using (MemoryStream destStream = new MemoryStream())
using (BinaryWriter writer = new BinaryWriter(destStream))
{
// Copy ICONDIR and ICONDIRENTRY.
writer.Write(srcBuf, 0, sICONDIR - 2);
writer.Write((short)1); // ICONDIR.idCount == 1;
writer.Write(srcBuf, sICONDIR + sICONDIRENTRY * i, sICONDIRENTRY - 4);
writer.Write(sICONDIR + sICONDIRENTRY); // ICONDIRENTRY.dwImageOffset = sizeof(ICONDIR) + sizeof(ICONDIRENTRY)
// Copy picture and mask data.
int imgSize = BitConverter.ToInt32(srcBuf, sICONDIR + sICONDIRENTRY * i + 8); // ICONDIRENTRY.dwBytesInRes
int imgOffset = BitConverter.ToInt32(srcBuf, sICONDIR + sICONDIRENTRY * i + 12); // ICONDIRENTRY.dwImageOffset
writer.Write(srcBuf, imgOffset, imgSize);
// Create new icon.
destStream.Seek(0, SeekOrigin.Begin);
splitIcons.Add(new Icon(destStream));
}
}
}
return splitIcons.ToArray();
}
private byte[] getIconBytesFromIcon(Icon icon)
{
try
{
using (MemoryStream ms = new MemoryStream())
{
icon.Save(ms);
return ms.ToArray();
}
}
catch (Exception)
{
return null;
}
}
public virtual void Init()
{
originalIcon = new Icon(GetType(), "TestIcon.ico");
file = "./yellow.ico";
using (FileStream stream = File.Create(file))
{
originalIcon.Save(stream);
}
}