public static IEnumerable<string> GetResourceNames()
{
var asm = Assembly.GetExecutingAssembly();
var names = asm.GetManifestResourceNames();
var resourceKey = ".resources";
foreach (var resName in names)
{
if (resName.EndsWith(resourceKey))
{
using (var stream = asm.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream))
{
foreach (var entry in reader.Cast<DictionaryEntry>())
{
var name = (string)entry.Key;
yield return resName.Substring(0, resName.Length - resourceKey.Length) + "." + name + " = " + entry.Value.GetType();
}
}
}
else
{
yield return resName;
}
}
}
public static byte[] Extract(Assembly assembly, string resourceName)
{
string resName = assembly.GetName().Name + ".g.resources";
using (var stream = assembly.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream))
{
IDictionaryEnumerator dict = reader.GetEnumerator();
while (dict.MoveNext())
{
if ((string)dict.Key == resourceName)
{
using (Stream streamInner = (Stream)dict.Value)
{
byte[] bytes = new byte[streamInner.Length];
streamInner.Read(bytes, 0, bytes.Length);
return(bytes);
}
}
}
}
using (Stream resFilestream = assembly.GetManifestResourceStream(resourceName))
{
if (resFilestream == null)
{
return(null);
}
byte[] bytes = new byte[resFilestream.Length];
resFilestream.Read(bytes, 0, bytes.Length);
return(bytes);
}
}
public IReadOnlyList <string> GetLicenses()
{
var result = new List <string>();
var assembly = Assembly.GetExecutingAssembly();
string resourcesName = assembly.GetName().Name + ".g.resources";
using (var stream = assembly.GetManifestResourceStream(resourcesName))
using (var reader = new System.Resources.ResourceReader(stream))
{
var entries = reader.Cast <DictionaryEntry>();
var entry = entries.First(o => ((string)o.Key) == "resources/licenses/index");
using (var indexreader = new StreamReader((Stream)entry.Value))
{
while (!indexreader.EndOfStream)
{
var line = indexreader.ReadLine();
if (!string.IsNullOrWhiteSpace(line))
{
result.Add(line);
}
}
}
}
return(result);
}
/// <summary>
/// Read string lines
/// </summary>
/// <param name="stream"></param>
/// <param name="lineFormat">unused</param>
/// <returns></returns>
public IEnumerable <KeyValuePair <string, IString> > ReadStringLines(Stream stream, ILineFormat lineFormat = default)
{
using (var reader = new System.Resources.ResourceReader(stream))
{
IDictionaryEnumerator dict = reader.GetEnumerator();
while (dict.MoveNext())
{
string key = null, value = null;
try
{
if (dict.Key is string _key && dict.Value is string _value)
{
key = _key; value = _value;
}
}
catch (Exception e)
{
throw new LocalizationException("Failed to read .resources file", e);
}
if (key != null && value != null)
{
IString formatString = ValueParser.Parse(value);
yield return(new KeyValuePair <string, IString>(key, formatString));
}
}
}
}
public static IEnumerable <string> GetResourceNames()
{
var asm = Assembly.GetExecutingAssembly();
var names = asm.GetManifestResourceNames();
var resourceKey = ".resources";
foreach (var resName in names)
{
if (resName.EndsWith(resourceKey))
{
using (var stream = asm.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream))
{
foreach (var entry in reader.Cast <DictionaryEntry>())
{
var name = (string)entry.Key;
yield return(resName.Substring(0, resName.Length - resourceKey.Length) + "." + name + " = " + entry.Value.GetType());
}
}
}
else
{
yield return(resName);
}
}
}
private bool _readXmlResorce(string key, out string xml)
{
xml = null;
string path = System.IO.Path.GetFullPath(_path);
if (System.IO.File.Exists(_path))
{
using (System.Resources.ResourceReader rdr = new System.Resources.ResourceReader(_path))
{
byte[] buffer = null;
/*string typeName;
* rdr.GetResourceData(key.ToLower(), out typeName, out buffer);*/
var dic = rdr.GetEnumerator();
while (dic.MoveNext())
{
if (dic.Key.ToString() == key.ToLower())
{
buffer = (byte[])dic.Value;
}
}
if (buffer != null && buffer.Length > 0)
{
xml = Encoding.Unicode.GetString(buffer);
return(true);
}
}
}
return(false);
}
private IEnumerable <string> GetRawResourceNames()
{
var asm = _assembly;
var resName = asm.GetName().Name + ".g.resources";
using (var stream = asm.GetManifestResourceStream(resName))
{
if (stream == null)
{
yield break;
}
using (var reader = new System.Resources.ResourceReader(stream))
{
foreach (DictionaryEntry entry in reader)
{
var rawResourceName = (string)entry.Key;
if (HasImageExtension(rawResourceName))
{
continue;
}
var binReader = new BamlBinaryReader((Stream)entry.Value);
var r = new BamlRootElementCheck(binReader);
var element = r.RootElement();
if (element == "ResourceDictionary")
{
yield return(rawResourceName);
}
}
}
}
}
///<summary>Loads a resource file from the EHR assembly and returns the file text as a string.
///Returns "" is the EHR assembly did not load. strResourceName can be either "CCD" or "CCR".
///This function performs a late binding to the EHR.dll, because resellers do not have EHR.dll necessarily.</summary>
public static string GetEhrResource(string strResourceName)
{
if (AssemblyEHR == null)
{
constructObjFormEhrMeasuresHelper();
if (AssemblyEHR == null)
{
return("");
}
}
Stream stream = AssemblyEHR.GetManifestResourceStream("EHR.Properties.Resources.resources");
System.Resources.ResourceReader resourceReader = new System.Resources.ResourceReader(stream);
string strResourceType = "";
byte[] arrayResourceBytes = null;
resourceReader.GetResourceData(strResourceName, out strResourceType, out arrayResourceBytes);
resourceReader.Dispose();
stream.Dispose();
MemoryStream ms = new MemoryStream(arrayResourceBytes);
BinaryReader br = new BinaryReader(ms);
string retVal = br.ReadString(); //Removes the leading binary characters from the string.
ms.Dispose();
br.Dispose();
return(retVal);
}
/// <summary>
/// Gets the icon set for the given index, using the given list for missing icons.
/// </summary>
/// <param name="index"></param>
/// <param name="defaultList"></param>
/// <returns></returns>
public static ImageList GetIconSet(int index, ImageList defaultList)
{
ImageList def = new ImageList();
def.ColorDepth = ColorDepth.Depth32Bit;
string groupname = null;
if (index > 0 && index < EVEMon.Common.Resources.Skill_Select.IconSettings.Default.Properties.Count)
{
groupname = EVEMon.Common.Resources.Skill_Select.IconSettings.Default.Properties["Group" + index].DefaultValue.ToString();
}
if ((groupname != null && !System.IO.File.Exists(String.Format(
"{1}Resources{0}Skill_Select{0}Group{2}{0}{3}.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory,
index,
groupname)) ||
!System.IO.File.Exists(String.Format(
"{1}Resources{0}Skill_Select{0}Group0{0}Default.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory))))
{
groupname = null;
}
if (groupname != null)
{
System.Resources.IResourceReader basic = new System.Resources.ResourceReader(String.Format(
"{1}Resources{0}Skill_Select{0}Group0{0}Default.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory));
IDictionaryEnumerator basicx = basic.GetEnumerator();
while (basicx.MoveNext())
{
def.Images.Add(basicx.Key.ToString(), (Icon)basicx.Value);
}
basic.Close();
basic = new System.Resources.ResourceReader(String.Format(
"{1}Resources{0}Skill_Select{0}Group{2}{0}{3}.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory,
index,
groupname));
basicx = basic.GetEnumerator();
while (basicx.MoveNext())
{
if (def.Images.ContainsKey(basicx.Key.ToString()))
{
def.Images.RemoveByKey(basicx.Key.ToString());
}
def.Images.Add(basicx.Key.ToString(), (Icon)basicx.Value);
}
basic.Close();
return(def);
}
else
{
return(defaultList);
}
}
public void CloseResources()
{
if (resourceReader != null)
{
resourceReader.Close();
resourceReader = null;
}
}
/// <summary>
/// Project Build Action: "Resource".
/// </summary>
public static string[] GetResourceKeys(Assembly assembly)
{
string resName = assembly.GetName().Name + ".g.resources";
using (var stream = assembly.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream))
return(reader.Cast <System.Collections.DictionaryEntry>().Select(x => (string)x.Key).ToArray());
}
// ******************************************************************
private static void DebugPrintResources(System.Resources.ResourceReader reader)
{
Debug.Print("Begin dump resources: ---------------------");
foreach (DictionaryEntry item in reader)
{
Debug.Print(item.Key.ToString());
}
Debug.Print("End dump resources: ---------------------");
}
private static UnmanagedMemoryStream GetDefaultKeyvault()
{
var assembly = Assembly.GetAssembly(typeof(Package <>));
var rStream = assembly.GetManifestResourceStream(assembly.GetName().Name + ".g.resources");
var resourceReader = new System.Resources.ResourceReader(rStream);
var items = resourceReader.OfType <System.Collections.DictionaryEntry>();
return((UnmanagedMemoryStream)items.First(x => x.Key.Equals("resources/kv_dec.bin")).Value);
}
public void LoadResourceBytes(byte[] resourceData)
{
// Decrypt the bytes
byte[] decryptedBytes = Utilities.CryptoUtils.Decrypt(resourceData, "asdlfa9sd879*Lasldflkajsdf243o8729");
MemoryStream memStream = new MemoryStream(decryptedBytes);
resourceReader = new System.Resources.ResourceReader(memStream);
}
/// <summary>
/// Enumerate the names of all resources contained in the provided assembly
/// </summary>
public IEnumerable<string> GetResourceNames()
{
var asm = _assembly;
var resName = asm.GetName().Name + ".g.resources";
using (var stream = asm.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream))
{
return reader.Cast<DictionaryEntry>().Select(entry => ((string)entry.Key).Replace(".baml","")).ToArray();
}
}
private List<String> GetNodeResourceNames()
{
var asm = Assembly.GetExecutingAssembly();
string resName = asm.GetName().Name + ".g.resources";
using (var stream = asm.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream))
{
return reader.Cast<DictionaryEntry>().Select(entry => (string)entry.Key).Where(key => key.Contains("node_")).ToList();
}
}
public static string[] GetResourceNames()
{
var asm = Assembly.GetEntryAssembly();
string resName = asm.GetName().Name + ".g.resources";
using (var stream = asm.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream)) {
return(reader.Cast <System.Collections.DictionaryEntry>().Select(entry => (string)entry.Key).ToArray());
}
}
string[] GetAvailableFiles(string category)
{
var asm = Assembly.GetExecutingAssembly();
string resName = asm.GetName().Name + ".g.resources";
using (var stream = asm.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream)) {
return(reader.Cast <DictionaryEntry>().Select(entry => (string)entry.Key).Where(entry => entry.StartsWith("images/hotels/" + category.ToLowerInvariant())).ToArray());
}
}
public virtual bool IsResourceDictionaryAvailable(string resourceDictionaryUri)
{
if (_resourceDictionaryExists.TryGetValue(resourceDictionaryUri, out var existingValue))
{
return(existingValue);
}
var expectedResourceNames = resourceDictionaryUri.Split(new[] { ";component/" }, StringSplitOptions.RemoveEmptyEntries);
if (expectedResourceNames.Length == 2)
{
// Part 1 is assembly
var assemblyName = expectedResourceNames[0].Replace("/", string.Empty);
var assembly = (from x in AppDomain.CurrentDomain.GetAssemblies()
where x.GetName().Name.EqualsIgnoreCase(assemblyName)
select x).FirstOrDefault();
if (assembly != null)
{
// Orchestra.Core.g.resources
var generatedResourceName = $"{assembly.GetName().Name}.g.resources";
using (var resourceStream = assembly.GetManifestResourceStream(generatedResourceName))
{
if (resourceStream is null)
{
Log.Debug($"Could not find generated resources @ '{generatedResourceName}', assuming the resource dictionary '{resourceDictionaryUri}' does not exist");
_resourceDictionaryExists[resourceDictionaryUri] = false;
return(false);
}
var relativeResourceName = expectedResourceNames[1].Replace(".xaml", ".baml");
using (var reader = new System.Resources.ResourceReader(resourceStream))
{
var exists = (from x in reader.Cast <DictionaryEntry>()
where ((string)x.Key).EqualsIgnoreCase(relativeResourceName)
select x).Any();
if (exists)
{
Log.Debug($"Resource '{resourceDictionaryUri}' exists");
_resourceDictionaryExists[resourceDictionaryUri] = true;
return(true);
}
}
}
}
}
Log.Debug($"Failed to confirm that resource '{resourceDictionaryUri}' exists");
_resourceDictionaryExists[resourceDictionaryUri] = false;
return(false);
}
private List <String> GetNodeResourceNames()
{
var asm = Assembly.GetExecutingAssembly();
string resName = asm.GetName().Name + ".g.resources";
using (var stream = asm.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream))
{
return(reader.Cast <DictionaryEntry>().Select(entry => (string)entry.Key).Where(key => key.Contains("node_")).ToList());
}
}
static TEmbeddedResource()
{
var asm = Assembly.GetEntryAssembly();
string resName = asm.GetName().Name + ".g.resources";
using (var stream = asm.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream))
{
Resources = reader.Cast <DictionaryEntry>().Where(t => t.Value is Stream).ToDictionary(t => t.Key.ToString(), k => (Stream)k.Value);
}
}
public static byte[] GetResourceBytes(string resourceName)
{
var assembly = Assembly.GetAssembly(typeof(ResourceHelper));
var rStream = assembly.GetManifestResourceStream(assembly.GetName().Name + ".g.resources");
var resourceReader = new System.Resources.ResourceReader(rStream);
var items = resourceReader.OfType <System.Collections.DictionaryEntry>();
var ums = (UnmanagedMemoryStream)items.First(x => x.Key.Equals("resources/" + resourceName.ToLower())).Value;
var bytes = new byte[ums.Length];
ums.Read(bytes, 0, bytes.Length);
return(bytes);
}
public static void FindAllFiles()
{
// uzyskanie listy Resource plikow projektu
var asm = Assembly.GetExecutingAssembly();
string resName = asm.GetName().Name + ".g.resources"; // Memory.g.resources zawiera wszystkie Resources
using (var stream = asm.GetManifestResourceStream(resName)) // System.IO.UnmanagedMemoryStream
using (var reader = new System.Resources.ResourceReader(stream)) // System.Resources.ResourceReader
{
FileList = reader.Cast <DictionaryEntry>().Where(entry => entry.Key.ToString().Contains(".png")).Select(entry => (string)entry.Key).ToList();
}
}
private static void createImageToActivity(AttributeTableBuilder builder, System.Resources.ResourceReader resourceReader, Type builtInActivityType)
{
System.Drawing.Bitmap bitmap = getImageFromResource(resourceReader, builtInActivityType.IsGenericType ? builtInActivityType.Name.Split('`')[0] : builtInActivityType.Name);
if (bitmap != null)
{
Type tbaType = typeof(System.Drawing.ToolboxBitmapAttribute);
Type imageType = typeof(System.Drawing.Image);
ConstructorInfo constructor = tbaType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { imageType, imageType }, null);
System.Drawing.ToolboxBitmapAttribute tba = constructor.Invoke(new object[] { bitmap, bitmap }) as System.Drawing.ToolboxBitmapAttribute;
builder.AddCustomAttributes(builtInActivityType, tba);
}
}
private static void LoadToolboxIconsForBuiltInActivities()
{
AttributeTableBuilder builder = new AttributeTableBuilder();
Assembly sourceAssembly = Assembly.LoadFile(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Microsoft.VisualStudio.Activities.dll"));
resourceReader = new System.Resources.ResourceReader(sourceAssembly.GetManifestResourceStream("Microsoft.VisualStudio.Activities.Resources.resources"));
foreach (Type type in typeof(System.Activities.Activity).Assembly.GetTypes().Where(t => t.Namespace == "System.Activities.Statements"))
{
CreateToolboxBitmapAttributeForActivity(builder, resourceReader, type);
}
MetadataStore.AddAttributeTable(builder.CreateTable());
}
/// <summary>
/// 初始化加载图标资源
/// </summary>
/// <returns></returns>
private DXImageGalleryLoader LoadData()
{
this.ImageCollection = new Dictionary <string, GalleryItem>();
this.Categories = new List <string>();
this.Collection = new List <string>();
this.Size = new List <string>();
using (System.Resources.ResourceReader reader = GetResourceReader(DevExpress.Utils.DxImageAssemblyUtil.ImageAssembly))
{
System.Collections.IDictionaryEnumerator dict = reader.GetEnumerator();
while (dict.MoveNext())
{
string key = (string)dict.Key as string;
if (!DevExpress.Utils.DxImageAssemblyUtil.ImageProvider.IsBrowsable(key))
{
continue;
}
if (key.EndsWith(".png", StringComparison.Ordinal))
{
string reg = @"(?<collection>\S*?)/(?<category>\S*?)/(?<name>\S*)";
var collectionItem = CRegex.GetText(key, reg, "collection");
var categoryItem = CRegex.GetText(key, reg, "category");
string sizeReg = @"_(?<size>\S*)\.";
var sizeItem = CRegex.GetText(key, sizeReg, "size");
if (!this.Collection.Contains(collectionItem))
{
this.Collection.Add(collectionItem);
}
if (!this.Categories.Contains(categoryItem))
{
this.Categories.Add(categoryItem);
}
if (!this.Size.Contains(sizeItem))
{
this.Size.Add(sizeItem);
}
Image image = GetImageFromStream((System.IO.Stream)dict.Value);
if (image != null)
{
var item = new DevExpress.XtraBars.Ribbon.GalleryItem(image, key, key);
if (!ImageCollection.ContainsKey(key))
{
ImageCollection.Add(key, item);
}
}
}
}
}
return(this);
}
public Portraits(Assembly assembly, string directory)
{
_available = new List <Portrait>();
_all = new Dictionary <string, Portrait>(StringComparer.OrdinalIgnoreCase);
string resName = assembly.GetName().Name + ".g.resources";
using (var stream = assembly.GetManifestResourceStream(resName)) {
using (var reader = new System.Resources.ResourceReader(stream)) {
foreach (var uri in reader.Cast <DictionaryEntry>().Select(entry => (string)entry.Key))
{
var key = Path.GetFileNameWithoutExtension(uri);
var dir = Path.GetDirectoryName(uri);
var type = Path.GetFileName(dir);
var portrait = new Portrait(key, "/" + uri);
if (string.Equals(type, "available", StringComparison.OrdinalIgnoreCase))
{
_available.Add(portrait);
}
else if (string.Equals(type, "Overridable", StringComparison.OrdinalIgnoreCase))
{
_available.Add(portrait);
}
if (!_all.ContainsKey(key))
{
_all.Add(key, portrait);
}
}
}
}
if (Directory.Exists(directory))
{
foreach (var folder in Directory.EnumerateDirectories(directory))
{
var uri = Directory.EnumerateFiles(folder, "Small.*").FirstOrDefault();
if (string.IsNullOrEmpty(uri))
{
continue;
}
var key = Path.GetFileName(folder);
var portrait = new Portrait(key, uri, isCustom: true);
_available.Add(portrait);
if (!_all.ContainsKey(key))
{
_all.Add(key, portrait);
}
}
}
}
public static byte[] GetResource(string name)
{
var asm = Assembly.GetEntryAssembly();
string resName = asm.GetName().Name + ".g.resources";
using (var stream = asm.GetManifestResourceStream(resName))
using (var reader = new System.Resources.ResourceReader(stream)) {
byte[] buffer;
string type = "System.Drawing.Bitmap";
reader.GetResourceData(name, out type, out buffer);
return(buffer);
}
}
private string[] GetAssemblyResourceNames()
{
var assembly = App.ResourceAssembly;
string resourceName = assembly.GetName().Name + ".g.resources";
using (var stream = assembly.GetManifestResourceStream(resourceName))
{
using (var reader = new System.Resources.ResourceReader(stream))
{
return(reader.Cast <System.Collections.DictionaryEntry>().Select(entry => (string)entry.Key).ToArray());
}
}
}
private string[] GetDefaultIcons()
{
var assembly = Assembly.GetExecutingAssembly();
string resourcesName = $"{assembly.GetName().Name}.g.resources";
using (var stream = assembly.GetManifestResourceStream(resourcesName))
{
using (var reader = new System.Resources.ResourceReader(stream))
{
return(reader.Cast <DictionaryEntry>().Select(entry => (string)entry.Key).ToArray());
}
}
}
private IEnumerable <ResourceKeyValue> GetResourceKeys(Type resourceType)
{
string fileName = string.Format("{0}.{1}.resx", resourceType.Name, this.CurrentCultureISO);
using (System.Resources.ResourceReader resourceReader = new System.Resources.ResourceReader(fileName))
{
IDictionaryEnumerator readerEnumerator = resourceReader.GetEnumerator();
while (readerEnumerator.MoveNext())
{
yield return(new ResourceKeyValue(readerEnumerator.Key.ToString(), readerEnumerator.Value.ToString()));
}
}
}
protected bool ResourceKeyExists(Type resourceType, string resourceKey)
{
bool exists = false;
string fileName = string.Format("{0}.{1}.resx", resourceType.Name, this.CurrentCultureISO);
using (System.Resources.ResourceReader resourceReader = new System.Resources.ResourceReader(fileName))
{
string resourceKeyType;
byte[] resourceKeyValue;
resourceReader.GetResourceData(resourceKey, out resourceKeyType, out resourceKeyValue);
exists = resourceKeyValue != null && resourceKeyValue.Length != 0;
}
return(exists);
}
/// <summary>
/// See <see cref="ResourceStorage.GetAllResourceKeys"/>
/// </summary>
/// <returns>The list of resource keys known to the storage.</returns>
public override List <string> GetAllResourceKeys()
{
lock (_cacheLock)
{
if (_ResourceData == null)
{
if (!_Cache.TryGetValue(_FileName, out _ResourceData))
{
if (!System.IO.File.Exists(_FileName))
{
throw new Core.LanguagePlatformException(Core.ErrorCode.LanguageResourceFileNotFound, Core.FaultStatus.Fatal);
}
_ResourceData = new ResourceFileData();
_ResourceData.ResourceNames = new List <string>();
_ResourceData.Data = new Dictionary <string, byte[]>();
System.Resources.ResourceReader rdr = null;
try
{
rdr = new System.Resources.ResourceReader(_FileName);
foreach (System.Collections.DictionaryEntry entry in rdr)
{
_ResourceData.ResourceNames.Add((string)entry.Key);
// this will effectively load all resources. Since the enumerator (which we
// need to determine the available resources) also returns the data itself,
// and since ResourceReader.GetResourceData() prefixes the data with an
// int which contains the size of the byte array, we rather store right now:
_ResourceData.Data.Add((string)entry.Key, (byte[])entry.Value);
}
_Cache.Add(_FileName, _ResourceData);
}
catch
{
throw new Core.LanguagePlatformException(Core.ErrorCode.InvalidLanguageResourceFile, Core.FaultStatus.Fatal);
}
finally
{
if (rdr != null)
{
rdr.Close();
}
}
}
}
}
return(_ResourceData.ResourceNames);
}
public static void loadSystemIcon()
{
AttributeTableBuilder builder = new AttributeTableBuilder();
string str = System.Environment.CurrentDirectory + @"\Microsoft.VisualStudio.Activities.dll";
Assembly sourceAssembly = Assembly.LoadFile(str);
System.Resources.ResourceReader resourceReader = new System.Resources.ResourceReader(sourceAssembly.GetManifestResourceStream("Microsoft.VisualStudio.Activities.Resources.resources"));
foreach (Type type in typeof(System.Activities.Activity).Assembly.GetTypes())
{
if (type.Namespace == "System.Activities.Statements")
{
createImageToActivity(builder, resourceReader, type);
}
}
MetadataStore.AddAttributeTable(builder.CreateTable());
}
public static string GetLangString(string Key, string langtype, string FilePath)
{
string filename;
switch (langtype)
{
case "cn": filename = "cn.resources"; break;
case "en": filename = "en.resources"; break;
default: filename = "cn.resources"; break;
}
System.Resources.ResourceReader reader = new System.Resources.ResourceReader(FilePath + filename);
string resourcetype;
byte[] resourcedata;
string result = string.Empty;
try
{
reader.GetResourceData(Key, out resourcetype, out resourcedata);
//去掉第一个字节，无用
byte[] arr = new byte[resourcedata.Length - 1];
for (int i = 0; i < arr.Length; i++)
{
arr[i] = resourcedata[i + 1];
}
result = System.Text.Encoding.UTF8.GetString(arr);
}
catch (Exception ex)
{
}
finally
{
reader.Close();
}
return result;
}
/// <summary>
/// Get the resource value
/// </summary>
/// <param name="resouceKey">Resouce Key</param>
/// <returns>Resource Key</returns>
public string GetResource(string resouceKey)
{
var resourceValue = string.Empty;
//Load the required assembly
var a = Assembly.Load(RESOURCE_ASSEMBLY_NAME);
if (a != null)
{
//Get all the resource files embedded inside the dll
var resourcelist = a.GetManifestResourceNames();
foreach (string resource in resourcelist.ToList())
{
//Load the specific resource file as a stream from the assembly.
var resourceStream = a.GetManifestResourceStream(resource);
if (resourceStream != null)
{
// Use the ResourceReader class and pass the stream generated in the above step to get the resource file data as key value pair in sequential order.
var resourceManager = new System.Resources.ResourceReader(resourceStream);
foreach (var item in resourceManager)
{
//match the resource from the list of resrouces
if (string.Equals(((System.Collections.DictionaryEntry) (item)).Key.ToString(), resouceKey,
StringComparison.OrdinalIgnoreCase))
{
resourceValue = ((System.Collections.DictionaryEntry) (item)).Value.ToString();
}
}
}
}
}
return resourceValue;
}
private static IEnumerable<string> LoadResources(Assembly assembly, string resourceSuffix)
{
var resources = new List<string>();
string resName = assembly.GetName().Name + resourceSuffix;
using (var stream = assembly.GetManifestResourceStream(resName))
{
if (stream != null)
{
using (var reader = new System.Resources.ResourceReader(stream))
{
resources.AddRange(reader
.Cast<DictionaryEntry>()
.Select(entry => (string)entry.Key));
}
}
}
return resources;
}
/// <summary>Will try to load the first icon from the resources</summary>
public System.Drawing.Icon LoadFirstIconFromResource()
{
// Get the assembly that is calling this method
System.Reflection.Assembly currentAssembly = System.Reflection.Assembly.GetCallingAssembly();
foreach(string s in currentAssembly.GetManifestResourceNames())
{
try
{
// See if there are any .icos
System.IO.Stream resourceStream = currentAssembly.GetManifestResourceStream(s);
return new System.Drawing.Icon(resourceStream);
}
catch
{
// No icon yet, try reading the resources in a different way
try
{
System.Resources.ResourceReader reader = new System.Resources.ResourceReader(currentAssembly.GetManifestResourceStream(s));
IDictionaryEnumerator en = reader.GetEnumerator();
while(en.MoveNext())
{
System.Drawing.Icon test = en.Value as System.Drawing.Icon;
if (test != null)
return test;
}
}
catch
{
// Didn't find an icon yet, continue
continue;
}
}
}
// It's no big deal if we can't load the icon, just return null instead
return null;
}
/// <summary>
/// Skill Planner > Skill browser icon set > Icons set combo.
/// Updates the sample below the combo box.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void skillIconSetComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
ImageList def = new ImageList();
def.ColorDepth = ColorDepth.Depth32Bit;
string groupname = null;
if (cbSkillIconSet.SelectedIndex >= 0 && cbSkillIconSet.SelectedIndex < IconSettings.Default.Properties.Count - 1)
groupname = IconSettings.Default.Properties["Group" + (cbSkillIconSet.SelectedIndex + 1)].DefaultValue.ToString();
if ((groupname != null
&& !System.IO.File.Exists(
String.Format(
"{1}Resources{0}Skill_Select{0}Group{2}{0}{3}.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory,
(cbSkillIconSet.SelectedIndex + 1),
groupname)))
|| !System.IO.File.Exists(
String.Format(
"{1}Resources{0}Skill_Select{0}Group0{0}Default.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory)))
{
groupname = null;
}
if (groupname != null)
{
System.Resources.IResourceReader basic = new System.Resources.ResourceReader(
String.Format(
"{1}Resources{0}Skill_Select{0}Group0{0}Default.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory));
System.Collections.IDictionaryEnumerator basicx = basic.GetEnumerator();
while (basicx.MoveNext())
{
def.Images.Add(basicx.Key.ToString(), (System.Drawing.Icon)basicx.Value);
}
basic.Close();
basic = new System.Resources.ResourceReader(
String.Format(
"{1}Resources{0}Skill_Select{0}Group{2}{0}{3}.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory,
(cbSkillIconSet.SelectedIndex + 1),
groupname));
basicx = basic.GetEnumerator();
while (basicx.MoveNext())
{
if (def.Images.ContainsKey(basicx.Key.ToString()))
def.Images.RemoveByKey(basicx.Key.ToString());
def.Images.Add(basicx.Key.ToString(), (System.Drawing.Icon)basicx.Value);
}
basic.Close();
}
tvlist.Nodes.Clear();
tvlist.ImageList = def;
tvlist.ImageList.ColorDepth = ColorDepth.Depth32Bit;
TreeNode gtn = new TreeNode("Book", tvlist.ImageList.Images.IndexOfKey("book"), tvlist.ImageList.Images.IndexOfKey("book"));
gtn.Nodes.Add(new TreeNode("Pre-Reqs NOT met (Rank)", tvlist.ImageList.Images.IndexOfKey("PrereqsNOTMet"), tvlist.ImageList.Images.IndexOfKey("PrereqsNOTMet")));
gtn.Nodes.Add(new TreeNode("Pre-Reqs met (Rank)", tvlist.ImageList.Images.IndexOfKey("PrereqsMet"), tvlist.ImageList.Images.IndexOfKey("PrereqsMet")));
for (int i = 0; i < 6; i++)
{
gtn.Nodes.Add(new TreeNode("Level " + i + " (Rank)", tvlist.ImageList.Images.IndexOfKey("lvl" + i), tvlist.ImageList.Images.IndexOfKey("lvl" + i)));
}
gtn.Expand();
tvlist.Nodes.Add(gtn);
}
private static IReadOnlyList<string> GetResourceNames( Assembly assembly, string resourceName )
{
Contract.Requires( assembly != null );
Contract.Requires( !string.IsNullOrEmpty( resourceName ) );
Contract.Ensures( Contract.Result<IReadOnlyList<string>>() != null );
Contract.Ensures( Contract.ForAll( Contract.Result<IReadOnlyList<string>>(), name => !string.IsNullOrEmpty( name ) ) );
// XAML resources are stored in the *.g.resources element
var manifestKey = XamlResourcesFormat.FormatInvariant( assembly.GetAssemblyName() );
IReadOnlyList<string> resourceNames;
// look up cached resource names
if ( xamlResources.TryGetValue( manifestKey, out resourceNames ) )
return resourceNames;
// no resources
if ( !assembly.GetManifestResourceNames().Contains( manifestKey, StringComparer.Ordinal ) )
throw new IOException( ExceptionMessage.MissingResourceException.FormatDefault( resourceName ) );
// prevent cache from group exponentially
if ( xamlResources.Count > 100 )
xamlResources.Clear();
using ( var stream = assembly.GetManifestResourceStream( manifestKey ) )
{
var reader = new System.Resources.ResourceReader( stream );
resourceNames = new List<string>( reader.Cast<System.Collections.DictionaryEntry>().Select( entry => (string) entry.Key ) );
}
// cache resource names so the manifest doesn't have to be reloaded
xamlResources[manifestKey] = resourceNames;
return resourceNames;
}
/// <summary>
/// Gets the icon set for the given index, using the given list for missing icons.
/// </summary>
/// <param name="index"></param>
/// <param name="defaultList"></param>
/// <returns></returns>
public static ImageList GetIconSet(int index, ImageList defaultList)
{
ImageList def = new ImageList();
def.ColorDepth = ColorDepth.Depth32Bit;
string groupname = null;
if (index > 0 && index < EVEMon.Common.Resources.Skill_Select.IconSettings.Default.Properties.Count)
{
groupname = EVEMon.Common.Resources.Skill_Select.IconSettings.Default.Properties["Group" + index].DefaultValue.ToString();
}
if ((groupname != null && !System.IO.File.Exists(String.Format(
"{1}Resources{0}Skill_Select{0}Group{2}{0}{3}.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory,
index,
groupname)) ||
!System.IO.File.Exists(String.Format(
"{1}Resources{0}Skill_Select{0}Group0{0}Default.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory))))
{
groupname = null;
}
if (groupname != null)
{
System.Resources.IResourceReader basic = new System.Resources.ResourceReader(String.Format(
"{1}Resources{0}Skill_Select{0}Group0{0}Default.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory));
IDictionaryEnumerator basicx = basic.GetEnumerator();
while (basicx.MoveNext())
{
def.Images.Add(basicx.Key.ToString(), (Icon)basicx.Value);
}
basic.Close();
basic = new System.Resources.ResourceReader(String.Format(
"{1}Resources{0}Skill_Select{0}Group{2}{0}{3}.resources",
Path.DirectorySeparatorChar,
System.AppDomain.CurrentDomain.BaseDirectory,
index,
groupname));
basicx = basic.GetEnumerator();
while (basicx.MoveNext())
{
if (def.Images.ContainsKey(basicx.Key.ToString()))
{
def.Images.RemoveByKey(basicx.Key.ToString());
}
def.Images.Add(basicx.Key.ToString(), (Icon)basicx.Value);
}
basic.Close();
return def;
}
else
{
return defaultList;
}
}
static void AddChildren( Assembly assem, Platform.ShellRightClickContextMenuClass menuClass, InfoStorageAttribute storage, IntPtr menu, dynamic children, List<string> selectedFiles, bool isRoot, MenuClick onClick )
{
for ( var i=0; i<children.Length; ++i )
{
dynamic item = children[ i ];
string name = Util.IsJsonProperty( item, "name" ) ? (string)item.name : "New Menu Item";
// embed image into assembly and reference that
System.Drawing.Bitmap bmp = null;
IntPtr subMenu = IntPtr.Zero;
if ( Util.IsJsonProperty( item, "imageResource" ) )
{
var resources = assem.GetManifestResourceStream( (string)item.imageResource + ".resources" );
var rr = new System.Resources.ResourceReader( resources );
string resourceType;
byte[] resourceData;
rr.GetResourceData( "image.bmp", out resourceType, out resourceData );
// For some reason the resource compiler adds 4 bytes to the start of our data.
bmp = new System.Drawing.Bitmap( new System.IO.MemoryStream( resourceData, 4, resourceData.Length-4 ) );
}
if ( Util.IsJsonProperty( item, "children" ) )
{
subMenu = menuClass.CreateSubMenu();
AddChildren( assem, menuClass, storage, subMenu, item.children, selectedFiles, false, onClick );
}
int position = i+1;
if ( isRoot )
{
position = Util.IsJsonProperty( item, "position" ) ? (int)item.position : position;
}
if ( menu == IntPtr.Zero )
{
// root element
if ( subMenu == IntPtr.Zero )
{
uint id = menuClass.InsertMenuItem( name, position, ( List<string> s ) => { onClick( item, selectedFiles ); } );
if ( bmp != null )
{
menuClass.SetMenuItemBitmap( id, bmp );
}
}
else
{
menuClass.InsertSubMenu( subMenu, name, position, bmp );
}
}
else
{
// sub menu
if ( subMenu == IntPtr.Zero )
{
menuClass.InsertMenuItemIntoSubMenu( menu, name, position, bmp, ( List<string> s ) => { onClick( item, selectedFiles ); } );
}
else
{
uint id = menuClass.InsertSubMenuIntoSubMenu( menu, subMenu, name, position );
if ( bmp != null )
{
menuClass.SetMenuItemBitmap( id, bmp );
}
}
}
}
}
// ******************************************************************
/// <summary>
/// The path separator is '/'. The path should not start with '/'.
/// </summary>
/// <param name="asm"></param>
/// <param name="path"></param>
/// <returns></returns>
public static Stream GetAssemblyResourceStream(Assembly asm, string path)
{
// Just to be sure
if (path[0] == '/')
{
path = path.Substring(1);
}
// Just to be sure
if (path.IndexOf('\\') == -1)
{
path = path.Replace('\\', '/');
}
Stream resStream = null;
string resName = asm.GetName().Name + ".g.resources"; // Ref: Thomas Levesque Answer at:
// http://stackoverflow.com/questions/2517407/enumerating-net-assembly-resources-at-runtime
using (var stream = asm.GetManifestResourceStream(resName))
{
using (var resReader = new System.Resources.ResourceReader(stream))
{
string dataType = null;
byte[] data = null;
try
{
resReader.GetResourceData(path.ToLower(), out dataType, out data);
}
catch (Exception ex)
{
DebugPrintResources(resReader);
}
if (data != null)
{
switch (dataType) // COde from
{
// Handle internally serialized string data (ResourceTypeCode members).
case "ResourceTypeCode.String":
BinaryReader reader = new BinaryReader(new MemoryStream(data));
string binData = reader.ReadString();
Console.WriteLine(" Recreated Value: {0}", binData);
break;
case "ResourceTypeCode.Int32":
Console.WriteLine(" Recreated Value: {0}", BitConverter.ToInt32(data, 0));
break;
case "ResourceTypeCode.Boolean":
Console.WriteLine(" Recreated Value: {0}", BitConverter.ToBoolean(data, 0));
break;
// .jpeg image stored as a stream.
case "ResourceTypeCode.Stream":
////const int OFFSET = 4;
////int size = BitConverter.ToInt32(data, 0);
////Bitmap value1 = new Bitmap(new MemoryStream(data, OFFSET, size));
////Console.WriteLine(" Recreated Value: {0}", value1);
const int OFFSET = 4;
resStream = new MemoryStream(data, OFFSET, data.Length - OFFSET);
break;
// Our only other type is DateTimeTZI.
default:
////// No point in deserializing data if the type is unavailable.
////if (dataType.Contains("DateTimeTZI") && loaded)
////{
//// BinaryFormatter binFmt = new BinaryFormatter();
//// object value2 = binFmt.Deserialize(new MemoryStream(data));
//// Console.WriteLine(" Recreated Value: {0}", value2);
////}
////break;
break;
}
// resStream = new MemoryStream(resData);
}
}
}
return resStream;
}
public static IEnumerable<string> WellKnownDirectoriesOf(string path)
{
var result = new List<string>();
if (_xml == null)
{
var assembly = Assembly.GetAssembly(typeof(DirectoryStructure));
var rStream = assembly.GetManifestResourceStream(assembly.GetName().Name + ".g.resources");
var resourceReader = new System.Resources.ResourceReader(rStream);
var items = resourceReader.OfType<System.Collections.DictionaryEntry>();
using (var stream = (UnmanagedMemoryStream)items.First(x => x.Key.Equals("resources/hdddirectorystructure.xml")).Value)
{
_xml = new XmlDocument();
_xml.Load(stream);
}
}
var splitter = new Regex(@"[/\\]");
var currentDir = _xml.SelectSingleNode("/Drive");
var parts = new Queue<string>(splitter.Split(path));
var foundEntryPoint = false;
while (currentDir != null && parts.Count > 0)
{
var p = parts.Dequeue();
if (string.IsNullOrEmpty(p)) continue;
var subDir = currentDir.ChildNodes.Cast<XmlElement>().FirstOrDefault(child =>
{
if (!child.HasAttribute("Name")) return false;
var r = new Regex(string.Format("^{0}$", child.GetAttribute("Name")));
return r.IsMatch(p);
});
if (foundEntryPoint)
{
currentDir = subDir;
}
else if (subDir != null)
{
foundEntryPoint = true;
currentDir = subDir;
}
}
if (currentDir != null)
{
foreach (XmlElement childNode in currentDir.ChildNodes)
{
if (childNode.HasAttribute("Name"))
{
result.Add(childNode.GetAttribute("Name"));
}
else if (childNode.HasAttribute("Value") && childNode.HasAttribute("Type"))
{
var type = Type.GetType(childNode.GetAttribute("Type"));
if (type.IsEnum)
{
var enumValue = Enum.Parse(type, childNode.GetAttribute("Value"), true);
var a = BitConverter.GetBytes((int)enumValue);
Array.Reverse(a);
result.Add(a.ToHex());
}
}
}
}
return result;
}
private IEnumerable<string> GetRawResourceNames()
{
var asm = _assembly;
var resName = asm.GetName().Name + ".g.resources";
using (var stream = asm.GetManifestResourceStream(resName))
{
if (stream == null)
yield break;
using (var reader = new System.Resources.ResourceReader(stream))
{
foreach (DictionaryEntry entry in reader)
{
var rawResourceName = (string) entry.Key;
if (HasImageExtension(rawResourceName)) continue;
var binReader = new BamlBinaryReader((Stream) entry.Value);
var r = new BamlRootElementCheck(binReader);
var element = r.RootElement();
if (element == "ResourceDictionary")
yield return rawResourceName;
}
}
}
}
///<summary>Loads a resource file from the EHR assembly and returns the file text as a string.
///Returns "" is the EHR assembly did not load. strResourceName can be either "CCD" or "CCR".
///This function performs a late binding to the EHR.dll, because resellers do not have EHR.dll necessarily.</summary>
public static string GetEhrResource(string strResourceName) {
if(AssemblyEHR==null) {
constructObjFormEhrMeasuresHelper();
if(AssemblyEHR==null) {
return "";
}
}
Stream stream=AssemblyEHR.GetManifestResourceStream("EHR.Properties.Resources.resources");
System.Resources.ResourceReader resourceReader=new System.Resources.ResourceReader(stream);
string strResourceType="";
byte[] arrayResourceBytes=null;
resourceReader.GetResourceData(strResourceName,out strResourceType,out arrayResourceBytes);
resourceReader.Dispose();
stream.Dispose();
MemoryStream ms=new MemoryStream(arrayResourceBytes);
BinaryReader br=new BinaryReader(ms);
string retVal=br.ReadString();//Removes the leading binary characters from the string.
ms.Dispose();
br.Dispose();
return retVal;
}
