internal IconInfo(IconResource resource, ResourceLanguage language, ushort width, ushort height, byte colors, byte[] dib, bool isPNG)
{
Icon = resource;
Language = language;
Size = new Size(width, height);
Colors = colors;
DIB = dib;
IsPNG = isPNG;
}
public async Task SaveAsync(string fileName, ResourceLanguage language, CursorGroupSaveFormat saveFormat)
{
using (var file = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None))
{
await SaveAsync(file, language, saveFormat).ConfigureAwait(false);
await file.FlushAsync().ConfigureAwait(false);
}
}
internal CursorInfo(CursorResource cursor, ResourceLanguage language, ushort hotspotX, ushort hotspotY, ushort width, ushort height, byte colors, byte[] dib, bool isPNG)
{
Cursor = cursor;
Language = language;
Hotspot = new Point(hotspotX, hotspotY);
Size = new Size(width, height);
Colors = colors;
DIB = dib;
IsPNG = isPNG;
}
public async Task <MessageTable> GetTableAsync(ResourceLanguage language)
{
var buffer = await GetBytesAsync(language).ConfigureAwait(false);
using (var mem = new MemoryStream(buffer))
{
var tuples = new List <Tuple <uint, uint, uint> >();
var resourceData = await mem.ReadStructAsync <MESSAGE_RESOURCE_DATA>().ConfigureAwait(false);
for (var i = 0; i < resourceData.NumberOfBlocks; i++)
{
var block = await mem.ReadStructAsync <MESSAGE_RESOURCE_BLOCK>().ConfigureAwait(false);
var tuple = new Tuple <uint, uint, uint>(block.OffsetToEntries, block.LowId, block.HighId);
tuples.Add(tuple);
}
var blocks = new MessageTableBlock[resourceData.NumberOfBlocks];
for (var i = 0; i < tuples.Count; i++)
{
var tuple = tuples[i];
mem.Seek(tuple.Item1, SeekOrigin.Begin);
var count = (tuple.Item3 - tuple.Item2).ToInt32() + 1;
var entries = new MessageTableEntry[count];
var id = tuple.Item2;
for (var j = 0; j < count; j++)
{
var resourceEntry = await mem.ReadStructAsync <MESSAGE_RESOURCE_ENTRY>().ConfigureAwait(false);
var stringBuffer = await mem.ReadBytesAsync(resourceEntry.Length - sizeof(uint)).ConfigureAwait(false);
var message = (resourceEntry.Flags == 0 ? Encoding.ASCII.GetString(stringBuffer) : Encoding.Unicode.GetString(stringBuffer));
var entry = new MessageTableEntry(id, message, resourceEntry.Flags != 0);
entries[j] = entry;
id++;
}
var block = new MessageTableBlock(tuple.Item2, tuple.Item3, tuple.Item1, entries);
blocks[i] = block;
}
var table = new MessageTable(this, language, blocks);
return(table);
}
}
/// <summary>
/// Class constructor, creates a resource with the indicated key and data for all the supported languages
/// </summary>
/// <param name="resourceKey">The resource key</param>
/// <param name="resourceData">The resource data</param>
/// <param name="startStatus">The resource start status</param>
public Resource(string resourceKey, string resourceData, ICollection <string> countryCodes, CheckStatus startStatus = CheckStatus.New)
: this()
{
this.Key = resourceKey;
this.CheckStatus = startStatus;
this.VersionId = this.Guid;
if (countryCodes != null)
{
foreach (string countryCode in countryCodes)
{
ResourceLanguage resourceLanguage = new ResourceLanguage(countryCode, resourceData);
}
}
}
private async Task <IconData> GetIconDataAsync(ResourceLanguage language)
{
var buffer = await GetBytesAsync(language).ConfigureAwait(false);
bool isPNG;
ushort width;
ushort height;
byte colorCount;
byte[] dib;
using (var mem = new MemoryStream(buffer))
{
isPNG = GraphicUtils.IsPNG(buffer);
if (!isPNG)
{
var header = await mem.ReadStructAsync <BITMAPINFOHEADER>().ConfigureAwait(false);
width = Convert.ToUInt16(header.biWidth);
height = Convert.ToUInt16(header.biHeight / 2);
colorCount = Convert.ToByte(header.biBitCount);
dib = mem.ToArray();
}
else
{
using (var png = System.Drawing.Image.FromStream(mem))
{
width = Convert.ToUInt16(png.Width);
height = Convert.ToUInt16(png.Height);
colorCount = 32;
dib = mem.ToArray();
}
}
}
var result = new IconData()
{
Width = width,
Height = height,
ColorCount = colorCount,
DIB = dib,
IsPNG = isPNG
};
return(result);
}
private void AddProjectItems(ResourceEntity entity, ResourceLanguage neutralLanguage, string languageFileName)
{
Contract.Requires(entity != null);
Contract.Requires(neutralLanguage != null);
Contract.Requires(!string.IsNullOrEmpty(languageFileName));
DteProjectFile projectFile = null;
foreach (var neutralLanguageProjectItem in ((DteProjectFile)neutralLanguage.ProjectFile).ProjectItems)
{
Contract.Assume(neutralLanguageProjectItem != null);
var collection = neutralLanguageProjectItem.Collection;
Contract.Assume(collection != null);
var projectItem = collection.AddFromFile(languageFileName);
Contract.Assume(projectItem != null);
var containingProject = projectItem.ContainingProject;
Contract.Assume(containingProject != null);
var projectName = containingProject.Name;
Contract.Assume(projectName != null);
if (projectFile == null)
{
projectFile = new DteProjectFile(_compositionHost.GetExportedValue <DteSolution>(), languageFileName, projectName, containingProject.UniqueName, projectItem);
}
else
{
projectFile.AddProject(projectName, projectItem);
}
}
if (projectFile != null)
{
entity.AddLanguage(projectFile);
}
}
private void AddProjectItems(ResourceEntity entity, ResourceLanguage neutralLanguage, string languageFileName)
{
ThreadHelper.ThrowIfNotOnUIThread();
DteProjectFile?projectFile = null;
var projectItems = (neutralLanguage.ProjectFile as DteProjectFile)?.ProjectItems;
if (projectItems == null)
{
entity.AddLanguage(new ProjectFile(languageFileName, entity.Container.SolutionFolder ?? string.Empty, entity.ProjectName, null));
return;
}
foreach (var neutralLanguageProjectItem in projectItems)
{
var collection = neutralLanguageProjectItem.Collection;
var projectItem = collection.AddFromFile(languageFileName);
var containingProject = projectItem.ContainingProject;
var projectName = containingProject.Name;
if (projectFile == null)
{
var solution = _exportProvider.GetExportedValue <DteSolution>();
projectFile = new DteProjectFile(solution, solution.SolutionFolder, languageFileName, projectName, containingProject.UniqueName, projectItem);
}
else
{
projectFile.AddProject(projectName, projectItem);
}
}
if (projectFile != null)
{
entity.AddLanguage(projectFile);
}
}
public async Task <Bitmap> GetBitmapAsync(Color backgroundColor, ResourceLanguage language)
{
var data = await GetCursorDataAsync(language).ConfigureAwait(false);
Bitmap result;
if (!data.IsPNG)
{
using (var icon = await GetIconAsync(language).ConfigureAwait(false))
{
var rect = new Rectangle(0, 0, icon.Width, icon.Height);
result = new Bitmap(rect.Width, rect.Height, PixelFormat.Format32bppArgb);
using (var graphics = System.Drawing.Graphics.FromImage(result))
{
using (var brush = new SolidBrush(backgroundColor))
graphics.FillRectangle(brush, rect);
graphics.DrawIcon(icon, rect);
}
result.MakeTransparent(backgroundColor);
}
}
else
{
using (var dibStream = new MemoryStream(data.DIB))
{
using (var png = System.Drawing.Image.FromStream(dibStream))
result = new Bitmap(png);
}
}
return(result);
}
public async Task <VersionInfo> GetInfoAsync(ResourceLanguage language)
{
var buffer = await GetBytesAsync(language).ConfigureAwait(false);
using (var mem = new MemoryStream(buffer))
{
var count = 3 * sizeof(ushort);
await mem.ReadBytesAsync(count).ConfigureAwait(false);
var key = await mem.ReadUnicodeStringAsync().ConfigureAwait(false);
if (key != "VS_VERSION_INFO")
{
throw new Exception("Invalid file version information.");
}
await AlignWordBoundaryAsync(mem).ConfigureAwait(false);
var ffiData = await mem.ReadStructAsync <VS_FIXEDFILEINFO>().ConfigureAwait(false);
var fixedFileInfo = new FixedFileInfo(ffiData);
await AlignWordBoundaryAsync(mem).ConfigureAwait(false);
var stringFileInfo = await StringFileInfo.LoadAsync(mem).ConfigureAwait(false);
await AlignWordBoundaryAsync(mem).ConfigureAwait(false);
var varFileInfo = await VarFileInfo.LoadAsync(mem).ConfigureAwait(false);
var info = new VersionInfo(this, language, fixedFileInfo, stringFileInfo, varFileInfo);
return(info);
}
}
public static string[] TeamList(TeamListResource TeamList, ResourceLanguage Lang)
{
string res = String.Format("{0}.TeamLists.{1}_{2}.txt", Namespace, TeamList.ToString(), Lang.ToString());
return(TextResourceToStringArray(res));
}
public async Task SaveAsync(Stream stream, ResourceLanguage language, IconGroupSaveFormat saveFormat)
{
if (saveFormat == IconGroupSaveFormat.Raw)
{
var buffer = await _resource.GetBytesAsync(language).ConfigureAwait(false);
await stream.WriteBytesAsync(buffer).ConfigureAwait(false);
}
else
{
var group = await _resource.GetGroupAsync(language).ConfigureAwait(false);
var offsets = new uint[group.Count];
var offset = (6 + (16 * offsets.Length)).ToUInt32();
for (var i = 0; i < group.Count; i++)
{
var entry = group[i];
offsets[i] = offset;
offset += entry.BytesInRes;
}
await stream.WriteUInt16Async(0).ConfigureAwait(false);
await stream.WriteUInt16Async(1).ConfigureAwait(false);
await stream.WriteUInt16Async(group.Count.ToUInt16()).ConfigureAwait(false);
for (var i = 0; i < group.Count; i++)
{
var entry = group[i];
var colorCount = Convert.ToUInt64(Math.Pow(2, entry.BitCount));
if (colorCount >= 256)
{
colorCount = 0;
}
await stream.WriteByteAsync(Convert.ToByte(entry.Width >= 256 ? 0 : entry.Width)).ConfigureAwait(false);
await stream.WriteByteAsync(Convert.ToByte(entry.Height >= 256 ? 0 : entry.Height)).ConfigureAwait(false);
await stream.WriteByteAsync(Convert.ToByte(colorCount)).ConfigureAwait(false);
await stream.WriteByteAsync(0).ConfigureAwait(false);
await stream.WriteUInt16Async(1).ConfigureAwait(false);
await stream.WriteUInt16Async(entry.BitCount).ConfigureAwait(false);
await stream.WriteUInt32Async(entry.BytesInRes).ConfigureAwait(false);
await stream.WriteUInt32Async(offsets[i]).ConfigureAwait(false);
}
var icons = _resource.Type.Resources.First(type => type.Id == ResourceType.Icon);
for (var i = 0; i < group.Count; i++)
{
var entry = group[i];
var resource = icons.First(r => r.Id == entry.IconId);
var buffer = await resource.GetBytesAsync(language).ConfigureAwait(false);
await stream.WriteBytesAsync(buffer).ConfigureAwait(false);
}
}
}
public VersionInfo GetInfo(ResourceLanguage language)
{
return(GetInfoAsync(language).GetAwaiter().GetResult());
}
public CursorGroup GetGroup(ResourceLanguage language)
{
return(GetGroupAsync(language).GetAwaiter().GetResult());
}
public async Task SaveAsync(string fileName, ResourceLanguage language)
{
await SaveAsync(fileName, language, IconGroupSaveFormat.Icon);
}
public Icon GetIcon(ResourceLanguage language)
{
return(GetIconAsync(language).GetAwaiter().GetResult());
}
public AcceleratorsTable Get(ResourceLanguage language)
{
return(GetAsync(language).GetAwaiter().GetResult());
}
public async Task <Bitmap> GetBitmapAsync(ResourceLanguage language)
{
return(await GetBitmapAsync(Color.Transparent, language).ConfigureAwait(false));
}
public void Save(string fileName, ResourceLanguage language)
{
Save(fileName, language, IconGroupSaveFormat.Icon);
}
public Bitmap GetBitmap(Color backgroundColor, ResourceLanguage language)
{
return(GetBitmapAsync(backgroundColor, language).GetAwaiter().GetResult());
}
public Bitmap GetBitmap(ResourceLanguage language)
{
return(GetBitmap(Color.Transparent, language));
}
public void Save(Stream stream, ResourceLanguage language)
{
Save(stream, language, IconGroupSaveFormat.Icon);
}
public async Task SaveAsync(Stream stream, ResourceLanguage language)
{
await SaveAsync(stream, language, IconGroupSaveFormat.Icon).ConfigureAwait(false);
}
public async Task <Icon> GetIconAsync(ResourceLanguage language)
{
var data = await GetCursorDataAsync(language).ConfigureAwait(false);
Icon icon;
if (!data.IsPNG)
{
using (var dibMem = new MemoryStream(data.DIB))
{
var header = await dibMem.ReadStructAsync <BITMAPINFOHEADER>().ConfigureAwait(false);
var width = header.biWidth.ToUInt16();
var height = (header.biHeight / 2).ToUInt16();
var colorCount = header.biBitCount;
using (var mem = new MemoryStream())
{
await mem.WriteUInt16Async(0).ConfigureAwait(false);
await mem.WriteUInt16Async(1).ConfigureAwait(false);
await mem.WriteUInt16Async(1).ConfigureAwait(false);
var colors = Convert.ToUInt64(Math.Pow(2, colorCount));
if (colors >= 256)
{
colors = 0;
}
await mem.WriteByteAsync(Convert.ToByte(width >= 256 ? 0 : width)).ConfigureAwait(false);
await mem.WriteByteAsync(Convert.ToByte(height >= 256 ? 0 : height)).ConfigureAwait(false);
await mem.WriteByteAsync(Convert.ToByte(colors)).ConfigureAwait(false);
await mem.WriteByteAsync(0).ConfigureAwait(false);
await mem.WriteUInt16Async(1).ConfigureAwait(false);
await mem.WriteUInt16Async(colorCount).ConfigureAwait(false);
await mem.WriteInt32Async(data.DIB.Length).ConfigureAwait(false);
await mem.WriteInt32Async(22).ConfigureAwait(false);
await mem.WriteBytesAsync(data.DIB).ConfigureAwait(false);
mem.Seek(0, SeekOrigin.Begin);
icon = new Icon(mem);
}
}
}
else
{
using (var dibMem = new MemoryStream(data.DIB))
{
using (var png = System.Drawing.Image.FromStream(dibMem))
{
using (var mem = new MemoryStream())
{
await mem.WriteUInt16Async(0).ConfigureAwait(false);
await mem.WriteUInt16Async(1).ConfigureAwait(false);
await mem.WriteUInt16Async(1).ConfigureAwait(false);
await mem.WriteByteAsync(Convert.ToByte(png.Width >= 256 ? 0 : png.Width)).ConfigureAwait(false);
await mem.WriteByteAsync(Convert.ToByte(png.Height >= 256 ? 0 : png.Height)).ConfigureAwait(false);
await mem.WriteByteAsync(0).ConfigureAwait(false); // 32-bit (16m colors) so 0
await mem.WriteByteAsync(0).ConfigureAwait(false);
await mem.WriteUInt16Async(1).ConfigureAwait(false);
await mem.WriteUInt16Async(32).ConfigureAwait(false);
await mem.WriteInt32Async(data.DIB.Length).ConfigureAwait(false);
await mem.WriteInt32Async(22).ConfigureAwait(false);
await mem.WriteBytesAsync(data.DIB).ConfigureAwait(false);
mem.Seek(0, SeekOrigin.Begin);
icon = new Icon(mem);
}
}
}
}
return(icon);
}
public void Save(Stream stream, ResourceLanguage language, IconGroupSaveFormat saveFormat)
{
SaveAsync(stream, language, saveFormat).GetAwaiter().GetResult();
}
public Bitmap GetBitmap(ResourceLanguage language)
{
return(GetBitmapAsync(language).GetAwaiter().GetResult());
}
public DialogBase GetDialog(ResourceLanguage language)
{
return(GetDialogAsync(language).GetAwaiter().GetResult());
}
public MessageTable GetTable(ResourceLanguage language)
{
return(GetTableAsync(language).GetAwaiter().GetResult());
}
public Menu GetMenu(ResourceLanguage language)
{
return(GetMenuAsync(language).GetAwaiter().GetResult());
}
public void Save(string fileName, ResourceLanguage language, IconGroupSaveFormat saveFormat)
{
SaveAsync(fileName, language, saveFormat).GetAwaiter().GetResult();
}
