Transparent tray icon, GPU total, AppID

1.x/trunk/ProcessHacker.Common/BaseConverter.cs

@@ -30,7 +30,7 @@ namespace ProcessHacker.Common
     /// </summary>
     public static class BaseConverter
     {
-        private static readonly int[] _reverseChars = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        private static int[] _reverseChars = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 37, 38, 39, 40, 41,
             42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 52,
             53, 54, 55, 56, 57, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -74,7 +74,7 @@ public static decimal ToNumber(string number, int b)
             if (b > 70)
                 return 0;
 
-            if (string.IsNullOrEmpty(number))
+            if (number == "")
                 return 0;
 
             bool negative = number[0] == '-';
@@ -95,8 +95,8 @@ public static decimal ToNumber(string number, int b)
 
             if (negative)
                 return -result;
-
-            return result;
+            else
+                return result;
         }
 
         /// <summary>
@@ -118,11 +118,11 @@ public static decimal ToNumberParse(string number)
         /// <returns></returns>
         public static decimal ToNumberParse(string number, bool allowNonStandardExts)
         {                              
-            if (string.IsNullOrEmpty(number))
+            if (number == "")
                 return 0;
 
             bool negative = number[0] == '-';
-            decimal result;
+            decimal result = 0;
 
             if (negative)
                 number = number.Substring(1);
@@ -169,8 +169,8 @@ public static decimal ToNumberParse(string number, bool allowNonStandardExts)
 
             if (negative)
                 return -result;
-
-            return result;
+            else
+                return result;
         }
     }
 }

1.x/trunk/ProcessHacker.Common/ByteStreamReader.cs

@@ -21,13 +21,15 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Text;
 
 namespace ProcessHacker.Common
 {
     public sealed class ByteStreamReader : Stream
     {
-        private readonly byte[] _data;
+        private byte[] _data;
         private long _position;
 
         public ByteStreamReader(byte[] data) 

1.x/trunk/ProcessHacker.Common/DeltaManager.cs

@@ -20,6 +20,8 @@
  * along with Process Hacker.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+using System.Collections.Generic;
+
 namespace ProcessHacker.Common
 {
     /// <summary>
@@ -36,10 +38,10 @@ public interface ISubtractor<T>
 
     public static class Subtractor
     {
-        private static readonly Int64Subtractor _int64Subtractor = new Int64Subtractor();
-        private static readonly Int32Subtractor _int32Subtractor = new Int32Subtractor();
-        private static readonly DoubleSubtractor _doubleSubtractor = new DoubleSubtractor();
-        private static readonly FloatSubtractor _floatSubtractor = new FloatSubtractor();
+        private static Int64Subtractor _int64Subtractor = new Int64Subtractor();
+        private static Int32Subtractor _int32Subtractor = new Int32Subtractor();
+        private static DoubleSubtractor _doubleSubtractor = new DoubleSubtractor();
+        private static FloatSubtractor _floatSubtractor = new FloatSubtractor();
 
         public static Int64Subtractor Int64Subtractor
         {
@@ -115,7 +117,7 @@ public interface IDeltaValue<T>
 
     public struct DeltaValue<T> : IDeltaValue<T>
     {
-        private readonly ISubtractor<T> _subtractor;
+        private ISubtractor<T> _subtractor;
         private T _value;
         private T _delta;
 

1.x/trunk/ProcessHacker.Common/EnumComparer.cs

@@ -6,6 +6,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Text;
 using System.Reflection.Emit;
 
 namespace ProcessHacker.Common
@@ -14,6 +15,7 @@ public sealed class EnumComparer<TEnum> : IEqualityComparer<TEnum>
         where TEnum : struct, IComparable, IConvertible, IFormattable
     {
         public static readonly EnumComparer<TEnum> Instance;
+
         private static readonly Func<TEnum, TEnum, bool> _equals;
         private static readonly Func<TEnum, int> _getHashCode;
 
@@ -51,11 +53,12 @@ private static void AssertTypeIsEnum()
         private static void AssertUnderlyingTypeIsSupported()
         {
             var underlyingType = Enum.GetUnderlyingType(typeof(TEnum));
-            ICollection<Type> supportedTypes = new[]
-            {
-                typeof(byte), typeof(sbyte), typeof(short), typeof(ushort),
-                typeof(int), typeof(uint), typeof(long), typeof(ulong)
-            };
+            ICollection<Type> supportedTypes =
+                new[]
+                {
+                    typeof (byte), typeof (sbyte), typeof (short), typeof (ushort),
+                    typeof (int), typeof (uint), typeof (long), typeof (ulong)
+                };
 
             if (supportedTypes.Contains(underlyingType))
                 return;
@@ -75,19 +78,18 @@ private static void AssertUnderlyingTypeIsSupported()
         /// <returns>The generated method.</returns>
         private static Func<TEnum, TEnum, bool> generateEquals()
         {
-            var method = new DynamicMethod(typeof(TEnum).Name + "_Equals", typeof(bool), new[] 
-            { 
-                typeof(TEnum), typeof(TEnum) 
-            }, typeof(TEnum), true);
-
+            var method = new DynamicMethod(typeof(TEnum).Name + "_Equals",
+                typeof(bool),
+                new[] { typeof(TEnum), typeof(TEnum) },
+                typeof(TEnum), true);
             var generator = method.GetILGenerator();
             // Writing body
             generator.Emit(OpCodes.Ldarg_0);    // load x to stack
             generator.Emit(OpCodes.Ldarg_1);    // load y to stack
             generator.Emit(OpCodes.Ceq);        // x == y
             generator.Emit(OpCodes.Ret);        // return result
-
-            return (Func<TEnum, TEnum, bool>)method.CreateDelegate(typeof(Func<TEnum, TEnum, bool>));
+            return (Func<TEnum, TEnum, bool>)method.CreateDelegate
+                (typeof(Func<TEnum, TEnum, bool>));
         }
 
         /// <summary>
@@ -102,11 +104,10 @@ private static Func<TEnum, TEnum, bool> generateEquals()
         /// <returns>The generated method.</returns>
         private static Func<TEnum, int> generateGetHashCode()
         {
-            var method = new DynamicMethod(typeof(TEnum).Name + "_GetHashCode", typeof(int), new[] 
-            { 
-                typeof(TEnum) 
-            }, typeof(TEnum), true);
-
+            var method = new DynamicMethod(typeof(TEnum).Name + "_GetHashCode",
+                typeof(int),
+                new[] { typeof(TEnum) },
+                typeof(TEnum), true);
             var generator = method.GetILGenerator();
             var underlyingType = Enum.GetUnderlyingType(typeof(TEnum));
             var getHashCodeMethod = underlyingType.GetMethod("GetHashCode");
@@ -117,7 +118,6 @@ private static Func<TEnum, int> generateGetHashCode()
             generator.Emit(OpCodes.Ldloca_S, castValue);        // load *castValue to stack
             generator.Emit(OpCodes.Call, getHashCodeMethod);    // castValue.GetHashCode()
             generator.Emit(OpCodes.Ret);                        // return result
-
             return (Func<TEnum, int>)method.CreateDelegate(typeof(Func<TEnum, int>));
         }
     }

1.x/trunk/ProcessHacker.Common/FreeList.cs

@@ -20,17 +20,19 @@
  * along with Process Hacker.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+using System;
 using System.Threading;
 
 namespace ProcessHacker.Common
 {
     /// <summary>
     /// Manages a list of free objects that can be re-used.
     /// </summary>
-    public class FreeList<T> where T : IResettable, new()
+    public class FreeList<T>
+        where T : IResettable, new()
     {
-        private readonly T[] _list;
-        private int _freeIndex;
+        private T[] _list;
+        private int _freeIndex = 0;
 
         public FreeList(int maximumCount)
         {

1.x/trunk/ProcessHacker.Common/IResettable.cs

@@ -1,4 +1,8 @@
-namespace ProcessHacker.Common
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ProcessHacker.Common
 {
     public interface IResettable
     {

1.x/trunk/ProcessHacker.Common/IdGenerator.cs

@@ -30,9 +30,9 @@ namespace ProcessHacker.Common
     /// </summary>
     public class IdGenerator
     {
-        private readonly int _step = 1;
-        private bool _sort;
-        private readonly List<int> _ids = new List<int>();
+        private int _step = 1;
+        private bool _sort = false;
+        private List<int> _ids = new List<int>();
         private int _id;
 
         /// <summary>
@@ -88,9 +88,11 @@ public int Pop()
 
                     return id;
                 }
-
-                id = this._id;
-                this._id += this._step;
+                else
+                {
+                    id = _id;
+                    _id += _step;
+                }
             }
 
             return id;

1.x/trunk/ProcessHacker.Common/LibC.cs

@@ -1,4 +1,8 @@
-namespace ProcessHacker.Common
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ProcessHacker.Common
 {
     public static class LibC
     {

1.x/trunk/ProcessHacker.Common/LinkedList.cs

@@ -1,4 +1,6 @@
-namespace ProcessHacker.Common
+using System;
+
+namespace ProcessHacker.Common
 {
     public class LinkedListEntry<T>
     {

1.x/trunk/ProcessHacker.Common/Logging.cs

@@ -22,14 +22,15 @@
 
 using System;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 
 namespace ProcessHacker.Common
 {
     public delegate void LoggingDelegate(string message);
 
     public static class Logging
     {
-        public enum Importance
+        public enum Importance : int
         {
             Information = 0,
             Warning,
@@ -39,18 +40,26 @@ public enum Importance
 
         public static event LoggingDelegate Logged;
 
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
+        private static extern void OutputDebugString(string OutputString);
+
+        private static object _logLock = new object();
+
         [Conditional("DEBUG")]
         public static void Log(Importance importance, string message)
         {
-            string debugMessage =
-                DateTime.Now.ToString("hh:mm:ss:fff:") +
-                " ProcessHacker (T" + System.Threading.Thread.CurrentThread.ManagedThreadId +
-                "): (" + importance.ToString() + ") " + message + "\r\n\r\n" + Environment.StackTrace;
+            lock (_logLock)
+            {
+                string debugMessage =
+                    DateTime.Now.ToString("hh:mm:ss:fff:") +
+                    " ProcessHacker (T" + System.Threading.Thread.CurrentThread.ManagedThreadId +
+                    "): (" + importance.ToString() + ") " + message + "\r\n\r\n" + Environment.StackTrace;
 
-            Debugger.Log(0, "DEBUG", debugMessage);
+                OutputDebugString(debugMessage);
 
-            if (Logged != null)
-                Logged(debugMessage);
+                if (Logged != null)
+                    Logged(debugMessage);
+            }
         }
 
         [Conditional("DEBUG")]
@@ -59,7 +68,7 @@ public static void Log(Exception ex)
             string message = ex.Message;
 
             if (ex.InnerException != null)
-                message += "\r\nInner exception:\r\n" + ex.InnerException;
+                message += "\r\nInner exception:\r\n" + ex.InnerException.ToString();
             if (ex.StackTrace != null)
                 message += "\r\n" + ex.StackTrace;
 

1.x/trunk/ProcessHacker.Common/Messaging/Message.cs

@@ -1,15 +1,23 @@
 using System;
+using System.Collections.Generic;
+using System.Text;
 
 namespace ProcessHacker.Common.Messaging
 {
     public class Message
     {
-        public object Tag { get; set; }
+        private object _tag;
+
+        public object Tag
+        {
+            get { return _tag; }
+            set { _tag = value; }
+        }
     }
 
     public class ActionMessage : Message
     {
-        private readonly Action _action;
+        private Action _action;
 
         public ActionMessage(Action action)
         {

1.x/trunk/ProcessHacker.Common/Messaging/MessageQueue.cs

@@ -1,17 +1,18 @@
 using System;
 using System.Collections.Generic;
+using System.Text;
 
 namespace ProcessHacker.Common.Messaging
 {
     public class MessageQueue
     {
-        private readonly Queue<Message> _queue = new Queue<Message>();
-        private readonly List<MessageQueueListener> _listeners = new List<MessageQueueListener>();
+        private Queue<Message> _queue = new Queue<Message>();
+        private List<MessageQueueListener> _listeners = new List<MessageQueueListener>();
 
         public MessageQueue()
         {
             // Action message listener.
-            this.AddListener(new MessageQueueListener<ActionMessage>(action => action.Action()));
+            this.AddListener(new MessageQueueListener<ActionMessage>((action) => action.Action()));
         }
 
         public void AddListener(MessageQueueListener listener)