220 lines
10 KiB
C#
220 lines
10 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="BitmapSelector.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Drawing {
|
|
using System;
|
|
using System.Configuration;
|
|
using System.Drawing.Configuration;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
|
|
/// <summary>
|
|
/// Provides methods to select from multiple bitmaps depending on a "bitmapSuffix" config setting.
|
|
/// </summary>
|
|
internal static class BitmapSelector {
|
|
|
|
/// <summary>
|
|
/// Gets the bitmap ID suffix defined in the application configuration, or string.Empty if
|
|
/// the suffix is not specified. Internal for unit tests
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// For performance, the suffix is cached in a static variable so it only has to be read
|
|
/// once per appdomain.
|
|
/// </remarks>
|
|
private static string _suffix;
|
|
internal static string Suffix {
|
|
get {
|
|
if (_suffix == null) {
|
|
_suffix = string.Empty;
|
|
var section = ConfigurationManager.GetSection("system.drawing") as SystemDrawingSection;
|
|
if (section != null) {
|
|
var value = section.BitmapSuffix;
|
|
if (value != null && value is string) {
|
|
_suffix = (string)value;
|
|
}
|
|
}
|
|
}
|
|
return _suffix;
|
|
}
|
|
set {
|
|
// So unit tests can clear the cached suffix
|
|
_suffix = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Appends the current suffix to <paramref name="filePath"/>. The suffix is appended
|
|
/// before the existing extension (if any). Internal for unit tests.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// The new path with the suffix included. If there is no suffix defined or there are
|
|
/// invalid characters in the original path, the original path is returned.
|
|
/// </returns>
|
|
internal static string AppendSuffix(string filePath) {
|
|
try {
|
|
return Path.ChangeExtension(filePath, Suffix + Path.GetExtension(filePath));
|
|
}
|
|
catch (ArgumentException) { // there are invalid characters in the path
|
|
return filePath;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns <paramref name="originalPath"/> with the current suffix appended (before the
|
|
/// existing extension) if the resulting file path exists; otherwise the original path is
|
|
/// returned.
|
|
/// </summary>
|
|
public static string GetFileName(string originalPath) {
|
|
if (Suffix == string.Empty)
|
|
return originalPath;
|
|
|
|
string newPath = AppendSuffix(originalPath);
|
|
return File.Exists(newPath) ? newPath : originalPath;
|
|
}
|
|
|
|
// Calls assembly.GetManifestResourceStream in a try/catch and returns null if not found
|
|
private static Stream GetResourceStreamHelper(Assembly assembly, Type type, string name) {
|
|
Stream stream = null;
|
|
try {
|
|
stream = assembly.GetManifestResourceStream(type, name);
|
|
}
|
|
catch (FileNotFoundException) {
|
|
}
|
|
return stream;
|
|
}
|
|
|
|
private static bool DoesAssemblyHaveCustomAttribute(Assembly assembly, string typeName) {
|
|
return DoesAssemblyHaveCustomAttribute(assembly, assembly.GetType(typeName));
|
|
}
|
|
|
|
private static bool DoesAssemblyHaveCustomAttribute(Assembly assembly, Type attrType) {
|
|
if (attrType != null) {
|
|
var attr = assembly.GetCustomAttributes(attrType, false);
|
|
if (attr.Length > 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// internal for unit tests
|
|
internal static bool SatelliteAssemblyOptIn(Assembly assembly) {
|
|
// Try 4.5 public attribute type first
|
|
if (DoesAssemblyHaveCustomAttribute(assembly, typeof(BitmapSuffixInSatelliteAssemblyAttribute))) {
|
|
return true;
|
|
}
|
|
|
|
// Also load attribute type by name for dlls compiled against older frameworks
|
|
return DoesAssemblyHaveCustomAttribute(assembly, "System.Drawing.BitmapSuffixInSatelliteAssemblyAttribute");
|
|
}
|
|
|
|
// internal for unit tests
|
|
internal static bool SameAssemblyOptIn(Assembly assembly) {
|
|
// Try 4.5 public attribute type first
|
|
if (DoesAssemblyHaveCustomAttribute(assembly, typeof(BitmapSuffixInSameAssemblyAttribute))) {
|
|
return true;
|
|
}
|
|
|
|
// Also load attribute type by name for dlls compiled against older frameworks
|
|
return DoesAssemblyHaveCustomAttribute(assembly, "System.Drawing.BitmapSuffixInSameAssemblyAttribute");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a resource stream loaded from the appropriate location according to the current
|
|
/// suffix.
|
|
/// </summary>
|
|
/// <param name="assembly">The assembly from which the stream is loaded</param>
|
|
/// <param name="type">The type whose namespace is used to scope the manifest resource name</param>
|
|
/// <param name="originalName">The name of the manifest resource being requested</param>
|
|
/// <returns>
|
|
/// The manifest resource stream corresponding to <paramref name="originalName"/> with the
|
|
/// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
|
|
/// </returns>
|
|
public static Stream GetResourceStream(Assembly assembly, Type type, string originalName) {
|
|
if (Suffix != string.Empty) {
|
|
try {
|
|
// Resource with suffix has highest priority
|
|
if (SameAssemblyOptIn(assembly)) {
|
|
string newName = AppendSuffix(originalName);
|
|
Stream stream = GetResourceStreamHelper(assembly, type, newName);
|
|
if (stream != null) {
|
|
return stream;
|
|
}
|
|
}
|
|
}
|
|
catch {
|
|
// Ignore failures and continue to try other options
|
|
}
|
|
|
|
try {
|
|
// Satellite assembly has second priority, using the original name
|
|
if (SatelliteAssemblyOptIn(assembly)) {
|
|
AssemblyName assemblyName = assembly.GetName();
|
|
assemblyName.Name += Suffix;
|
|
assemblyName.ProcessorArchitecture = ProcessorArchitecture.None;
|
|
Assembly satellite = Assembly.Load(assemblyName);
|
|
if (satellite != null) {
|
|
Stream stream = GetResourceStreamHelper(satellite, type, originalName);
|
|
if (stream != null) {
|
|
return stream;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch {
|
|
// Ignore failures and continue to try other options
|
|
}
|
|
}
|
|
|
|
// Otherwise fall back to specified assembly and original name requested
|
|
return assembly.GetManifestResourceStream(type, originalName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a resource stream loaded from the appropriate location according to the current
|
|
/// suffix.
|
|
/// </summary>
|
|
/// <param name="type">The type from whose assembly the stream is loaded and whose namespace is used to scope the resource name</param>
|
|
/// <param name="originalName">The name of the manifest resource being requested</param>
|
|
/// <returns>
|
|
/// The manifest resource stream corresponding to <paramref name="originalName"/> with the
|
|
/// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
|
|
/// </returns>
|
|
public static Stream GetResourceStream(Type type, string originalName) {
|
|
return GetResourceStream(type.Module.Assembly, type, originalName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns an Icon created from a resource stream loaded from the appropriate location according to the current
|
|
/// suffix.
|
|
/// </summary>
|
|
/// <param name="type">The type from whose assembly the stream is loaded and whose namespace is used to scope the resource name</param>
|
|
/// <param name="originalName">The name of the manifest resource being requested</param>
|
|
/// <returns>
|
|
/// The icon created from a manifest resource stream corresponding to <paramref name="originalName"/> with the
|
|
/// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
|
|
/// </returns>
|
|
public static Icon CreateIcon(Type type, string originalName) {
|
|
return new Icon(GetResourceStream(type, originalName));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns an Bitmap created from a resource stream loaded from the appropriate location according to the current
|
|
/// suffix.
|
|
/// </summary>
|
|
/// <param name="type">The type from whose assembly the stream is loaded and whose namespace is used to scope the resource name</param>
|
|
/// <param name="originalName">The name of the manifest resource being requested</param>
|
|
/// <returns>
|
|
/// The bitmap created from a manifest resource stream corresponding to <paramref name="originalName"/> with the
|
|
/// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
|
|
/// </returns>
|
|
public static Bitmap CreateBitmap(Type type, string originalName) {
|
|
return new Bitmap(GetResourceStream(type, originalName));
|
|
}
|
|
|
|
}
|
|
}
|