822 lines
26 KiB
C#
822 lines
26 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Windows;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Imaging;
|
|
|
|
namespace Standard;
|
|
|
|
internal static class Utility
|
|
{
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
private static bool _MemCmp(IntPtr left, IntPtr right, long cb)
|
|
{
|
|
int num = 0;
|
|
while ((long) num < cb - 8L)
|
|
{
|
|
long num2 = Marshal.ReadInt64(left, num);
|
|
long num3 = Marshal.ReadInt64(right, num);
|
|
if (num2 != num3)
|
|
{
|
|
return false;
|
|
}
|
|
num += 8;
|
|
}
|
|
while ((long) num < cb)
|
|
{
|
|
byte b = Marshal.ReadByte(left, num);
|
|
byte b2 = Marshal.ReadByte(right, num);
|
|
if (b != b2)
|
|
{
|
|
return false;
|
|
}
|
|
num++;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static int RGB(Color c)
|
|
{
|
|
return (int) c.R | (int) c.G << 8 | (int) c.B << 16;
|
|
}
|
|
|
|
public static Color ColorFromArgbDword(uint color)
|
|
{
|
|
return Color.FromArgb((byte) ((color & 4278190080u) >> 24), (byte) ((color & 16711680u) >> 16), (byte) ((color & 65280u) >> 8), (byte) (color & 255u));
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static int GET_X_LPARAM(IntPtr lParam)
|
|
{
|
|
return Utility.LOWORD(lParam.ToInt32());
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static int GET_Y_LPARAM(IntPtr lParam)
|
|
{
|
|
return Utility.HIWORD(lParam.ToInt32());
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static int HIWORD(int i)
|
|
{
|
|
return (int) ((short) (i >> 16));
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static int LOWORD(int i)
|
|
{
|
|
return (int) ((short) (i & 65535));
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static bool AreStreamsEqual(Stream left, Stream right)
|
|
{
|
|
if (left == null)
|
|
{
|
|
return right == null;
|
|
}
|
|
if (right == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (!left.CanRead || !right.CanRead)
|
|
{
|
|
throw new NotSupportedException("The streams can't be read for comparison");
|
|
}
|
|
if (left.Length != right.Length)
|
|
{
|
|
return false;
|
|
}
|
|
int num = (int) left.Length;
|
|
left.Position = 0L;
|
|
right.Position = 0L;
|
|
int i = 0;
|
|
int num2 = 0;
|
|
byte[] array = new byte[512];
|
|
byte[] array2 = new byte[512];
|
|
GCHandle gchandle = GCHandle.Alloc(array, GCHandleType.Pinned);
|
|
IntPtr left2 = gchandle.AddrOfPinnedObject();
|
|
GCHandle gchandle2 = GCHandle.Alloc(array2, GCHandleType.Pinned);
|
|
IntPtr right2 = gchandle2.AddrOfPinnedObject();
|
|
bool result;
|
|
try
|
|
{
|
|
while (i < num)
|
|
{
|
|
int num3 = left.Read(array, 0, array.Length);
|
|
int num4 = right.Read(array2, 0, array2.Length);
|
|
if (num3 != num4)
|
|
{
|
|
return false;
|
|
}
|
|
if (!Utility._MemCmp(left2, right2, (long) num3))
|
|
{
|
|
return false;
|
|
}
|
|
i += num3;
|
|
num2 += num4;
|
|
}
|
|
result = true;
|
|
}
|
|
finally
|
|
{
|
|
gchandle.Free();
|
|
gchandle2.Free();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static bool GuidTryParse(string guidString, out Guid guid)
|
|
{
|
|
Verify.IsNeitherNullNorEmpty(guidString, "guidString");
|
|
try
|
|
{
|
|
guid = new Guid(guidString);
|
|
return true;
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
}
|
|
catch (OverflowException)
|
|
{
|
|
}
|
|
guid = default(Guid);
|
|
return false;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static bool IsFlagSet(int value, int mask)
|
|
{
|
|
return 0 != (value & mask);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static bool IsFlagSet(uint value, uint mask)
|
|
{
|
|
return 0u != (value & mask);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static bool IsFlagSet(long value, long mask)
|
|
{
|
|
return 0L != (value & mask);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static bool IsFlagSet(ulong value, ulong mask)
|
|
{
|
|
return 0UL != (value & mask);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static bool IsOSVistaOrNewer
|
|
{
|
|
get
|
|
{
|
|
return Utility._osVersion >= new Version(6, 0);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static bool IsOSWindows7OrNewer
|
|
{
|
|
get
|
|
{
|
|
return Utility._osVersion >= new Version(6, 1);
|
|
}
|
|
}
|
|
|
|
public static bool IsPresentationFrameworkVersionLessThan4
|
|
{
|
|
get
|
|
{
|
|
return Utility._presentationFrameworkVersion < new Version(4, 0);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
[SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times")]
|
|
public static IntPtr GenerateHICON(ImageSource image, Size dimensions)
|
|
{
|
|
if (image == null)
|
|
{
|
|
return IntPtr.Zero;
|
|
}
|
|
BitmapFrame bitmapFrame = image as BitmapFrame;
|
|
if (bitmapFrame != null)
|
|
{
|
|
bitmapFrame = Utility.GetBestMatch(bitmapFrame.Decoder.Frames, (int) dimensions.Width, (int) dimensions.Height);
|
|
}
|
|
else
|
|
{
|
|
Rect rectangle = new Rect(0.0, 0.0, dimensions.Width, dimensions.Height);
|
|
double num = dimensions.Width / dimensions.Height;
|
|
double num2 = image.Width / image.Height;
|
|
if (image.Width <= dimensions.Width && image.Height <= dimensions.Height)
|
|
{
|
|
rectangle = new Rect((dimensions.Width - image.Width) / 2.0, (dimensions.Height - image.Height) / 2.0, image.Width, image.Height);
|
|
}
|
|
else if (num > num2)
|
|
{
|
|
double num3 = image.Width / image.Height * dimensions.Width;
|
|
rectangle = new Rect((dimensions.Width - num3) / 2.0, 0.0, num3, dimensions.Height);
|
|
}
|
|
else if (num < num2)
|
|
{
|
|
double num4 = image.Height / image.Width * dimensions.Height;
|
|
rectangle = new Rect(0.0, (dimensions.Height - num4) / 2.0, dimensions.Width, num4);
|
|
}
|
|
DrawingVisual drawingVisual = new DrawingVisual();
|
|
DrawingContext drawingContext = drawingVisual.RenderOpen();
|
|
drawingContext.DrawImage(image, rectangle);
|
|
drawingContext.Close();
|
|
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap((int) dimensions.Width, (int) dimensions.Height, 96.0, 96.0, PixelFormats.Pbgra32);
|
|
renderTargetBitmap.Render(drawingVisual);
|
|
bitmapFrame = BitmapFrame.Create(renderTargetBitmap);
|
|
}
|
|
IntPtr result;
|
|
using (MemoryStream memoryStream = new MemoryStream())
|
|
{
|
|
new PngBitmapEncoder
|
|
{
|
|
Frames =
|
|
{
|
|
bitmapFrame
|
|
}
|
|
}.Save(memoryStream);
|
|
using (ManagedIStream managedIStream = new ManagedIStream(memoryStream))
|
|
{
|
|
IntPtr zero = IntPtr.Zero;
|
|
try
|
|
{
|
|
Status status = NativeMethods.GdipCreateBitmapFromStream(managedIStream, out zero);
|
|
if (status != Status.Ok)
|
|
{
|
|
result = IntPtr.Zero;
|
|
}
|
|
else
|
|
{
|
|
IntPtr intPtr;
|
|
status = NativeMethods.GdipCreateHICONFromBitmap(zero, out intPtr);
|
|
if (status != Status.Ok)
|
|
{
|
|
result = IntPtr.Zero;
|
|
}
|
|
else
|
|
{
|
|
result = intPtr;
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Utility.SafeDisposeImage(ref zero);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static BitmapFrame GetBestMatch(IList<BitmapFrame> frames, int width, int height)
|
|
{
|
|
return Utility._GetBestMatch(frames, Utility._GetBitDepth(), width, height);
|
|
}
|
|
|
|
private static int _MatchImage(BitmapFrame frame, int bitDepth, int width, int height, int bpp)
|
|
{
|
|
return 2 * Utility._WeightedAbs(bpp, bitDepth, false) + Utility._WeightedAbs(frame.PixelWidth, width, true) + Utility._WeightedAbs(frame.PixelHeight, height, true);
|
|
}
|
|
|
|
private static int _WeightedAbs(int valueHave, int valueWant, bool fPunish)
|
|
{
|
|
int num = valueHave - valueWant;
|
|
if (num < 0)
|
|
{
|
|
num = (fPunish ? -2 : -1) * num;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
private static BitmapFrame _GetBestMatch(IList<BitmapFrame> frames, int bitDepth, int width, int height)
|
|
{
|
|
int num = int.MaxValue;
|
|
int num2 = 0;
|
|
int index = 0;
|
|
bool flag = frames[0].Decoder is IconBitmapDecoder;
|
|
int num3 = 0;
|
|
while (num3 < frames.Count && num != 0)
|
|
{
|
|
int num4 = flag ? frames[num3].Thumbnail.Format.BitsPerPixel : frames[num3].Format.BitsPerPixel;
|
|
if (num4 == 0)
|
|
{
|
|
num4 = 8;
|
|
}
|
|
int num5 = Utility._MatchImage(frames[num3], bitDepth, width, height, num4);
|
|
if (num5 < num)
|
|
{
|
|
index = num3;
|
|
num2 = num4;
|
|
num = num5;
|
|
}
|
|
else if (num5 == num && num2 < num4)
|
|
{
|
|
index = num3;
|
|
num2 = num4;
|
|
}
|
|
num3++;
|
|
}
|
|
return frames[index];
|
|
}
|
|
|
|
private static int _GetBitDepth()
|
|
{
|
|
if (Utility.s_bitDepth == 0)
|
|
{
|
|
using (SafeDC desktop = SafeDC.GetDesktop())
|
|
{
|
|
Utility.s_bitDepth = NativeMethods.GetDeviceCaps(desktop, DeviceCap.BITSPIXEL) * NativeMethods.GetDeviceCaps(desktop, DeviceCap.PLANES);
|
|
}
|
|
}
|
|
return Utility.s_bitDepth;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static void SafeDeleteFile(string path)
|
|
{
|
|
if (!string.IsNullOrEmpty(path))
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static void SafeDeleteObject(ref IntPtr gdiObject)
|
|
{
|
|
IntPtr intPtr = gdiObject;
|
|
gdiObject = IntPtr.Zero;
|
|
if (IntPtr.Zero != intPtr)
|
|
{
|
|
NativeMethods.DeleteObject(intPtr);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static void SafeDestroyIcon(ref IntPtr hicon)
|
|
{
|
|
IntPtr intPtr = hicon;
|
|
hicon = IntPtr.Zero;
|
|
if (IntPtr.Zero != intPtr)
|
|
{
|
|
NativeMethods.DestroyIcon(intPtr);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static void SafeDestroyWindow(ref IntPtr hwnd)
|
|
{
|
|
IntPtr hwnd2 = hwnd;
|
|
hwnd = IntPtr.Zero;
|
|
if (NativeMethods.IsWindow(hwnd2))
|
|
{
|
|
NativeMethods.DestroyWindow(hwnd2);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static void SafeDispose<T>(ref T disposable) where T : IDisposable
|
|
{
|
|
IDisposable disposable2 = disposable;
|
|
disposable = default(T);
|
|
if (disposable2 != null)
|
|
{
|
|
disposable2.Dispose();
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static void SafeDisposeImage(ref IntPtr gdipImage)
|
|
{
|
|
IntPtr intPtr = gdipImage;
|
|
gdipImage = IntPtr.Zero;
|
|
if (IntPtr.Zero != intPtr)
|
|
{
|
|
NativeMethods.GdipDisposeImage(intPtr);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
|
|
public static void SafeCoTaskMemFree(ref IntPtr ptr)
|
|
{
|
|
IntPtr intPtr = ptr;
|
|
ptr = IntPtr.Zero;
|
|
if (IntPtr.Zero != intPtr)
|
|
{
|
|
Marshal.FreeCoTaskMem(intPtr);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static void SafeFreeHGlobal(ref IntPtr hglobal)
|
|
{
|
|
IntPtr intPtr = hglobal;
|
|
hglobal = IntPtr.Zero;
|
|
if (IntPtr.Zero != intPtr)
|
|
{
|
|
Marshal.FreeHGlobal(intPtr);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
|
|
public static void SafeRelease<T>(ref T comObject) where T : class
|
|
{
|
|
T t = comObject;
|
|
comObject = default(T);
|
|
if (t != null)
|
|
{
|
|
Marshal.ReleaseComObject(t);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static void GeneratePropertyString(StringBuilder source, string propertyName, string value)
|
|
{
|
|
if (source.Length != 0)
|
|
{
|
|
source.Append(' ');
|
|
}
|
|
source.Append(propertyName);
|
|
source.Append(": ");
|
|
if (string.IsNullOrEmpty(value))
|
|
{
|
|
source.Append("<null>");
|
|
return;
|
|
}
|
|
source.Append('"');
|
|
source.Append(value);
|
|
source.Append('"');
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
[Obsolete]
|
|
public static string GenerateToString<T>(T @object) where T : struct
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
foreach (PropertyInfo propertyInfo in typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public))
|
|
{
|
|
if (stringBuilder.Length != 0)
|
|
{
|
|
stringBuilder.Append(", ");
|
|
}
|
|
object value = propertyInfo.GetValue(@object, null);
|
|
string format = (value == null) ? "{0}: <null>" : "{0}: \"{1}\"";
|
|
stringBuilder.AppendFormat(format, propertyInfo.Name, value);
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static void CopyStream(Stream destination, Stream source)
|
|
{
|
|
destination.Position = 0L;
|
|
if (source.CanSeek)
|
|
{
|
|
source.Position = 0L;
|
|
destination.SetLength(source.Length);
|
|
}
|
|
byte[] array = new byte[4096];
|
|
int num;
|
|
do
|
|
{
|
|
num = source.Read(array, 0, array.Length);
|
|
if (num != 0)
|
|
{
|
|
destination.Write(array, 0, num);
|
|
}
|
|
}
|
|
while (array.Length == num);
|
|
destination.Position = 0L;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static string HashStreamMD5(Stream stm)
|
|
{
|
|
stm.Position = 0L;
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
using (MD5 md = MD5.Create())
|
|
{
|
|
foreach (byte b in md.ComputeHash(stm))
|
|
{
|
|
stringBuilder.Append(b.ToString("x2", CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static void EnsureDirectory(string path)
|
|
{
|
|
if (!Directory.Exists(Path.GetDirectoryName(path)))
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(path));
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static bool MemCmp(byte[] left, byte[] right, int cb)
|
|
{
|
|
GCHandle gchandle = GCHandle.Alloc(left, GCHandleType.Pinned);
|
|
IntPtr left2 = gchandle.AddrOfPinnedObject();
|
|
GCHandle gchandle2 = GCHandle.Alloc(right, GCHandleType.Pinned);
|
|
IntPtr right2 = gchandle2.AddrOfPinnedObject();
|
|
bool result = Utility._MemCmp(left2, right2, (long) cb);
|
|
gchandle.Free();
|
|
gchandle2.Free();
|
|
return result;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static string UrlDecode(string url)
|
|
{
|
|
if (url == null)
|
|
{
|
|
return null;
|
|
}
|
|
Utility._UrlDecoder urlDecoder = new Utility._UrlDecoder(url.Length, Encoding.UTF8);
|
|
int length = url.Length;
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
char c = url[i];
|
|
if (c == '+')
|
|
{
|
|
urlDecoder.AddByte(32);
|
|
}
|
|
else
|
|
{
|
|
if (c == '%' && i < length - 2)
|
|
{
|
|
if (url[i + 1] == 'u' && i < length - 5)
|
|
{
|
|
int num = Utility._HexToInt(url[i + 2]);
|
|
int num2 = Utility._HexToInt(url[i + 3]);
|
|
int num3 = Utility._HexToInt(url[i + 4]);
|
|
int num4 = Utility._HexToInt(url[i + 5]);
|
|
if (num >= 0 && num2 >= 0 && num3 >= 0 && num4 >= 0)
|
|
{
|
|
urlDecoder.AddChar((char) (num << 12 | num2 << 8 | num3 << 4 | num4));
|
|
i += 5;
|
|
goto IL_12D;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int num5 = Utility._HexToInt(url[i + 1]);
|
|
int num6 = Utility._HexToInt(url[i + 2]);
|
|
if (num5 >= 0 && num6 >= 0)
|
|
{
|
|
urlDecoder.AddByte((byte) (num5 << 4 | num6));
|
|
i += 2;
|
|
goto IL_12D;
|
|
}
|
|
}
|
|
}
|
|
if ((c & 'ﾀ') == '\0')
|
|
{
|
|
urlDecoder.AddByte((byte) c);
|
|
}
|
|
else
|
|
{
|
|
urlDecoder.AddChar(c);
|
|
}
|
|
}
|
|
IL_12D:;
|
|
}
|
|
return urlDecoder.GetString();
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public static string UrlEncode(string url)
|
|
{
|
|
if (url == null)
|
|
{
|
|
return null;
|
|
}
|
|
byte[] array = Encoding.UTF8.GetBytes(url);
|
|
bool flag = false;
|
|
int num = 0;
|
|
foreach (byte b in array)
|
|
{
|
|
if (b == 32)
|
|
{
|
|
flag = true;
|
|
}
|
|
else if (!Utility._UrlEncodeIsSafe(b))
|
|
{
|
|
num++;
|
|
flag = true;
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
byte[] array3 = new byte[array.Length + num * 2];
|
|
int num2 = 0;
|
|
foreach (byte b2 in array)
|
|
{
|
|
if (Utility._UrlEncodeIsSafe(b2))
|
|
{
|
|
array3[num2++] = b2;
|
|
}
|
|
else if (b2 == 32)
|
|
{
|
|
array3[num2++] = 43;
|
|
}
|
|
else
|
|
{
|
|
array3[num2++] = 37;
|
|
array3[num2++] = Utility._IntToHex(b2 >> 4 & 15);
|
|
array3[num2++] = Utility._IntToHex((int) (b2 & 15));
|
|
}
|
|
}
|
|
array = array3;
|
|
}
|
|
return Encoding.ASCII.GetString(array);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
private static bool _UrlEncodeIsSafe(byte b)
|
|
{
|
|
if (Utility._IsAsciiAlphaNumeric(b))
|
|
{
|
|
return true;
|
|
}
|
|
if (b != 33)
|
|
{
|
|
switch (b)
|
|
{
|
|
case 39:
|
|
case 40:
|
|
case 41:
|
|
case 42:
|
|
case 45:
|
|
case 46:
|
|
return true;
|
|
case 43:
|
|
case 44:
|
|
break;
|
|
default:
|
|
if (b == 95)
|
|
{
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
private static bool _IsAsciiAlphaNumeric(byte b)
|
|
{
|
|
return (b >= 97 && b <= 122) || (b >= 65 && b <= 90) || (b >= 48 && b <= 57);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
private static byte _IntToHex(int n)
|
|
{
|
|
if (n <= 9)
|
|
{
|
|
return (byte) (n + 48);
|
|
}
|
|
return (byte) (n - 10 + 65);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
private static int _HexToInt(char h)
|
|
{
|
|
if (h >= '0' && h <= '9')
|
|
{
|
|
return (int) (h - '0');
|
|
}
|
|
if (h >= 'a' && h <= 'f')
|
|
{
|
|
return (int) (h - 'a' + '\n');
|
|
}
|
|
if (h >= 'A' && h <= 'F')
|
|
{
|
|
return (int) (h - 'A' + '\n');
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static void AddDependencyPropertyChangeListener(object component, DependencyProperty property, EventHandler listener)
|
|
{
|
|
if (component == null)
|
|
{
|
|
return;
|
|
}
|
|
DependencyPropertyDescriptor dependencyPropertyDescriptor = DependencyPropertyDescriptor.FromProperty(property, component.GetType());
|
|
dependencyPropertyDescriptor.AddValueChanged(component, listener);
|
|
}
|
|
|
|
public static void RemoveDependencyPropertyChangeListener(object component, DependencyProperty property, EventHandler listener)
|
|
{
|
|
if (component == null)
|
|
{
|
|
return;
|
|
}
|
|
DependencyPropertyDescriptor dependencyPropertyDescriptor = DependencyPropertyDescriptor.FromProperty(property, component.GetType());
|
|
dependencyPropertyDescriptor.RemoveValueChanged(component, listener);
|
|
}
|
|
|
|
public static bool IsThicknessNonNegative(Thickness thickness)
|
|
{
|
|
return Utility.IsDoubleFiniteAndNonNegative(thickness.Top) && Utility.IsDoubleFiniteAndNonNegative(thickness.Left) && Utility.IsDoubleFiniteAndNonNegative(thickness.Bottom) && Utility.IsDoubleFiniteAndNonNegative(thickness.Right);
|
|
}
|
|
|
|
public static bool IsCornerRadiusValid(CornerRadius cornerRadius)
|
|
{
|
|
return Utility.IsDoubleFiniteAndNonNegative(cornerRadius.TopLeft) && Utility.IsDoubleFiniteAndNonNegative(cornerRadius.TopRight) && Utility.IsDoubleFiniteAndNonNegative(cornerRadius.BottomLeft) && Utility.IsDoubleFiniteAndNonNegative(cornerRadius.BottomRight);
|
|
}
|
|
|
|
public static bool IsDoubleFiniteAndNonNegative(double d)
|
|
{
|
|
return !double.IsNaN(d) && !double.IsInfinity(d) && d >= 0.0;
|
|
}
|
|
|
|
private static readonly Version _osVersion = Environment.OSVersion.Version;
|
|
|
|
private static readonly Version _presentationFrameworkVersion = Assembly.GetAssembly(typeof(Window)).GetName().Version;
|
|
|
|
private static int s_bitDepth;
|
|
|
|
private class _UrlDecoder
|
|
{
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public _UrlDecoder(int size, Encoding encoding)
|
|
{
|
|
this._encoding = encoding;
|
|
this._charBuffer = new char[size];
|
|
this._byteBuffer = new byte[size];
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public void AddByte(byte b)
|
|
{
|
|
this._byteBuffer[this._byteCount++] = b;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public void AddChar(char ch)
|
|
{
|
|
this._FlushBytes();
|
|
this._charBuffer[this._charCount++] = ch;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
private void _FlushBytes()
|
|
{
|
|
if (this._byteCount > 0)
|
|
{
|
|
this._charCount += this._encoding.GetChars(this._byteBuffer, 0, this._byteCount, this._charBuffer, this._charCount);
|
|
this._byteCount = 0;
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
public string GetString()
|
|
{
|
|
this._FlushBytes();
|
|
if (this._charCount > 0)
|
|
{
|
|
return new string(this._charBuffer, 0, this._charCount);
|
|
}
|
|
return "";
|
|
}
|
|
|
|
private readonly Encoding _encoding;
|
|
|
|
private readonly char[] _charBuffer;
|
|
|
|
private readonly byte[] _byteBuffer;
|
|
|
|
private int _byteCount;
|
|
|
|
private int _charCount;
|
|
}
|
|
}
|