Tobias Bohnen avatar Tobias Bohnen committed be64632

* IColour renamed IArgb

Comments (0)

Files changed (27)

SharpImage/Codecs/C64/GoDot/GoDotDecoder.cs

     {
         #region Fields
 
-        private static Palette palette = new Palette(new IColour[]
+        private static Palette palette = new Palette(new IArgb[]
         {
             new Rgb888(0, 0, 0),
             new Rgb888(0, 0, 0xaa),

SharpImage/ColourTranslator.cs

     {
         #region Fields
 
-        private static IDictionary<string, IColour> knownColours = new Dictionary<string, IColour>
+        private static IDictionary<string, IArgb> knownColours = new Dictionary<string, IArgb>
         {
             { "none", new Argb8888(0, 0, 0, 0) },
             { "snow", new Rgb888(255, 250, 250) },
 
         #region Public Static Methods
 
-        public static IColour FromHex(string name)
+        public static IArgb FromHex(string name)
         {
             if (!name.StartsWith("#"))
             {
             }
         }
 
-        public static IColour FromKnownName(string name)
+        public static IArgb FromKnownName(string name)
         {
             return knownColours[name.ToLowerInvariant()];
         }
 
-        public static IColour FromString(string name)
+        public static IArgb FromString(string name)
         {
             if (name.StartsWith("#"))
             {

SharpImage/Data/Abgr8888.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Abgr8888 : IEquatable<IColour>, IColour
+    public struct Abgr8888 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
             this.A = 255;
         }
 
-        public Abgr8888(IColour colour)
+        public Abgr8888(IArgb colour)
             : this(colour.A, colour.R, colour.G, colour.B)
         {
         }
 
         #region Explicit Interface Properties
 
-        byte IColour.A
+        byte IArgb.A
         {
             get
             {
             }
         }
 
-        byte IColour.B
+        byte IArgb.B
         {
             get
             {
             }
         }
 
-        byte IColour.G
+        byte IArgb.G
         {
             get
             {
             }
         }
 
-        byte IColour.R
+        byte IArgb.R
         {
             get
             {
             }
         }
 
-        int IColour.Value
+        int IArgb.Value
         {
             get
             {
             return new Abgr8888(other.R, other.G, other.B);
         }
 
-        public static bool operator !=(Abgr8888 left, IColour right)
+        public static bool operator !=(Abgr8888 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Abgr8888 left, IColour right)
+        public static bool operator ==(Abgr8888 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/Argb1555.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Argb1555 : IEquatable<IColour>, IColour
+    public struct Argb1555 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
 
         #region Explicit Interface Properties
 
-        int IColour.Value
+        int IArgb.Value
         {
             get
             {
 
         #region Public Static Methods
 
-        public static bool operator !=(Argb1555 left, IColour right)
+        public static bool operator !=(Argb1555 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Argb1555 left, IColour right)
+        public static bool operator ==(Argb1555 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/Argb2101010.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Argb2101010 : IEquatable<IColour>, IColour
+    public struct Argb2101010 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
 
         #region Explicit Interface Properties
 
-        int IColour.Value
+        int IArgb.Value
         {
             get
             {
 
         #region Public Static Methods
 
-        public static bool operator !=(Argb2101010 left, IColour right)
+        public static bool operator !=(Argb2101010 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Argb2101010 left, IColour right)
+        public static bool operator ==(Argb2101010 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/Argb4444.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Argb4444 : IEquatable<IColour>, IColour
+    public struct Argb4444 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
 
         #region Explicit Interface Properties
 
-        int IColour.Value
+        int IArgb.Value
         {
             get
             {
 
         #region Public Static Methods
 
-        public static bool operator !=(Argb4444 left, IColour right)
+        public static bool operator !=(Argb4444 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Argb4444 left, IColour right)
+        public static bool operator ==(Argb4444 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/Argb8888.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Argb8888 : IEquatable<IColour>, IColour
+    public struct Argb8888 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
             this.A = 255;
         }
 
-        public Argb8888(IColour colour)
+        public Argb8888(IArgb colour)
             : this(colour.A, colour.R, colour.G, colour.B)
         {
         }
 
         #region Explicit Interface Properties
 
-        byte IColour.A
+        byte IArgb.A
         {
             get
             {
             }
         }
 
-        byte IColour.B
+        byte IArgb.B
         {
             get
             {
             }
         }
 
-        byte IColour.G
+        byte IArgb.G
         {
             get
             {
             }
         }
 
-        byte IColour.R
+        byte IArgb.R
         {
             get
             {
             }
         }
 
-        int IColour.Value
+        int IArgb.Value
         {
             get
             {
             return new Argb8888(other.R, other.G, other.B);
         }
 
-        public static bool operator !=(Argb8888 left, IColour right)
+        public static bool operator !=(Argb8888 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Argb8888 left, IColour right)
+        public static bool operator ==(Argb8888 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/Bgr888.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Bgr888 : IEquatable<IColour>, IColour
+    public struct Bgr888 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
 
         #region Explicit Interface Properties
 
-        byte IColour.A
+        byte IArgb.A
         {
             get
             {
             }
         }
 
-        byte IColour.B
+        byte IArgb.B
         {
             get
             {
             }
         }
 
-        byte IColour.G
+        byte IArgb.G
         {
             get
             {
             }
         }
 
-        byte IColour.R
+        byte IArgb.R
         {
             get
             {
             return new Bgr888(other.R, other.G, other.B);
         }
 
-        public static bool operator !=(Bgr888 left, IColour right)
+        public static bool operator !=(Bgr888 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Bgr888 left, IColour right)
+        public static bool operator ==(Bgr888 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/Bgra8888.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Bgra8888 : IEquatable<IColour>, IColour
+    public struct Bgra8888 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
             this.A = 255;
         }
 
-        public Bgra8888(IColour colour)
+        public Bgra8888(IArgb colour)
             : this(colour.A, colour.R, colour.G, colour.B)
         {
         }
 
         #region Explicit Interface Properties
 
-        byte IColour.A
+        byte IArgb.A
         {
             get
             {
             }
         }
 
-        byte IColour.B
+        byte IArgb.B
         {
             get
             {
             }
         }
 
-        byte IColour.G
+        byte IArgb.G
         {
             get
             {
             }
         }
 
-        byte IColour.R
+        byte IArgb.R
         {
             get
             {
             }
         }
 
-        int IColour.Value
+        int IArgb.Value
         {
             get
             {
             return new Bgra8888(other.R, other.G, other.B);
         }
 
-        public static bool operator !=(Bgra8888 left, IColour right)
+        public static bool operator !=(Bgra8888 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Bgra8888 left, IColour right)
+        public static bool operator ==(Bgra8888 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/IArgb.cs

+/*
+ SharpImage
+ Copyright (c) 2012 Tobias Bohnen
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this
+ software and associated documentation files (the "Software"), to deal in the Software
+ without restriction, including without limitation the rights to use, copy, modify, merge,
+ publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+ to whom the Software is furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or
+ substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+ FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS IN THE SOFTWARE.
+ */
+namespace SharpImage.Data
+{
+    public interface IArgb
+    {
+        #region Properties
+
+        byte A
+        {
+            get;
+            set;
+        }
+
+        byte B
+        {
+            get;
+            set;
+        }
+
+        byte G
+        {
+            get;
+            set;
+        }
+
+        byte R
+        {
+            get;
+            set;
+        }
+
+        int Value
+        {
+            get;
+        }
+
+        #endregion Properties
+    }
+}

SharpImage/Data/IColour.cs

-/*
- SharpImage
- Copyright (c) 2012 Tobias Bohnen
-
- Permission is hereby granted, free of charge, to any person obtaining a copy of this
- software and associated documentation files (the "Software"), to deal in the Software
- without restriction, including without limitation the rights to use, copy, modify, merge,
- publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
- to whom the Software is furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in all copies or
- substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
- INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
- PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
- FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- DEALINGS IN THE SOFTWARE.
- */
-namespace SharpImage.Data
-{
-    public interface IColour
-    {
-        #region Properties
-
-        byte A
-        {
-            get;
-            set;
-        }
-
-        byte B
-        {
-            get;
-            set;
-        }
-
-        byte G
-        {
-            get;
-            set;
-        }
-
-        byte R
-        {
-            get;
-            set;
-        }
-
-        int Value
-        {
-            get;
-        }
-
-        #endregion Properties
-    }
-}

SharpImage/Data/Rgb332.cs

     using System.Runtime.InteropServices;
 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
-    public struct Rgb332 : IEquatable<IColour>, IColour
+    public struct Rgb332 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
 
         #region Explicit Interface Properties
 
-        byte IColour.A
+        byte IArgb.A
         {
             get { return 255; }
 
             }
         }
 
-        int IColour.Value
+        int IArgb.Value
         {
             get
             {
 
         #region Public Static Methods
 
-        public static bool operator !=(Rgb332 left, IColour right)
+        public static bool operator !=(Rgb332 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Rgb332 left, IColour right)
+        public static bool operator ==(Rgb332 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/Rgb555.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Rgb555 : IEquatable<IColour>, IColour
+    public struct Rgb555 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
 
         #region Explicit Interface Properties
 
-        byte IColour.A
+        byte IArgb.A
         {
             get { return 255; }
 
             }
         }
 
-        int IColour.Value
+        int IArgb.Value
         {
             get
             {
 
         #region Public Static Methods
 
-        public static bool operator !=(Rgb555 left, IColour right)
+        public static bool operator !=(Rgb555 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Rgb555 left, IColour right)
+        public static bool operator ==(Rgb555 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/Rgb565.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Rgb565 : IEquatable<IColour>, IColour
+    public struct Rgb565 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
 
         #region Explicit Interface Properties
 
-        byte IColour.A
+        byte IArgb.A
         {
             get { return 255; }
 
             }
         }
 
-        int IColour.Value
+        int IArgb.Value
         {
             get
             {
 
         #region Public Static Methods
 
-        public static bool operator !=(Rgb565 left, IColour right)
+        public static bool operator !=(Rgb565 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Rgb565 left, IColour right)
+        public static bool operator ==(Rgb565 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/Rgb888.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Rgb888 : IEquatable<IColour>, IColour
+    public struct Rgb888 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
 
         #region Explicit Interface Properties
 
-        byte IColour.A
+        byte IArgb.A
         {
             get
             {
             }
         }
 
-        byte IColour.B
+        byte IArgb.B
         {
             get
             {
             }
         }
 
-        byte IColour.G
+        byte IArgb.G
         {
             get
             {
             }
         }
 
-        byte IColour.R
+        byte IArgb.R
         {
             get
             {
             return new Rgb888(other.R, other.G, other.B);
         }
 
-        public static bool operator !=(Rgb888 left, IColour right)
+        public static bool operator !=(Rgb888 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Rgb888 left, IColour right)
+        public static bool operator ==(Rgb888 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Data/Rgba8888.cs

 
     [StructLayout(LayoutKind.Explicit, Pack = 1)]
     [Serializable]
-    public struct Rgba8888 : IEquatable<IColour>, IColour
+    public struct Rgba8888 : IEquatable<IArgb>, IArgb
     {
         #region Fixed Fields
 
 
         #region Constructors
 
-        public Rgba8888(IColour colour)
+        public Rgba8888(IArgb colour)
             : this(colour.A, colour.R, colour.G, colour.B)
         {
         }
 
         #region Explicit Interface Properties
 
-        byte IColour.A
+        byte IArgb.A
         {
             get
             {
             }
         }
 
-        byte IColour.B
+        byte IArgb.B
         {
             get
             {
             }
         }
 
-        byte IColour.G
+        byte IArgb.G
         {
             get
             {
             }
         }
 
-        byte IColour.R
+        byte IArgb.R
         {
             get
             {
             }
         }
 
-        int IColour.Value
+        int IArgb.Value
         {
             get
             {
             return new Rgba8888(other.R, other.G, other.B);
         }
 
-        public static bool operator !=(Rgba8888 left, IColour right)
+        public static bool operator !=(Rgba8888 left, IArgb right)
         {
             return !left.Equals(right);
         }
 
-        public static bool operator ==(Rgba8888 left, IColour right)
+        public static bool operator ==(Rgba8888 left, IArgb right)
         {
             return left.Equals(right);
         }
 
         #region Public Methods
 
-        public bool Equals(IColour other)
+        public bool Equals(IArgb other)
         {
-            return ((IColour)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
+            return ((IArgb)this).A == other.A && this.B == other.B && this.G == other.G && this.R == other.R;
         }
 
         public override bool Equals(object obj)
         {
-            return obj is IColour && this.Equals((IColour)obj);
+            return obj is IArgb && this.Equals((IArgb)obj);
         }
 
         public override int GetHashCode()

SharpImage/Drawing/Canvas.cs

 
         #region Public Methods
 
-        public void Clear(IColour colour)
+        public void Clear(IArgb colour)
         {
             var size = this.frame.Size;
             Parallel.For(0, size.Height, y =>
                          });
         }
 
-        public void DrawCircle(Point pos, int radius, IColour colour)
+        public void DrawCircle(Point pos, int radius, IArgb colour)
         {
             this.DrawCircle(pos, radius, colour, false);
         }
 
-        public void DrawDrawable(IDrawable drawable, IColour colour)
+        public void DrawDrawable(IDrawable drawable, IArgb colour)
         {
             if (drawable.IsPolygon)
             {
             }
         }
 
-        public void DrawEllipse(Point pos, int radiusX, int radiusY, IColour colour)
+        public void DrawEllipse(Point pos, int radiusX, int radiusY, IArgb colour)
         {
             this.DrawEllipse(pos, radiusX, radiusY, colour, false);
         }
 
-        public void DrawFilledCircle(Point pos, int radius, IColour colour)
+        public void DrawFilledCircle(Point pos, int radius, IArgb colour)
         {
             this.DrawCircle(pos, radius, colour, true);
         }
 
-        public void DrawFilledEllipse(Point pos, int radiusX, int radiusY, IColour colour)
+        public void DrawFilledEllipse(Point pos, int radiusX, int radiusY, IArgb colour)
         {
             this.DrawEllipse(pos, radiusX, radiusY, colour, true);
         }
 
-        public void DrawFilledRectangle(Rectangle rectangle, IColour colour)
+        public void DrawFilledRectangle(Rectangle rectangle, IArgb colour)
         {
             this.DrawRectangle(rectangle, colour, true);
         }
                 });
         }
 
-        public void DrawLine(Point point1, Point point2, IColour colour)
+        public void DrawLine(Point point1, Point point2, IArgb colour)
         {
             int x0 = point1.X;
             int x1 = point2.X;
             }
         }
 
-        public void DrawPath(IList<Point> points, IColour colour)
+        public void DrawPath(IList<Point> points, IArgb colour)
         {
             for (int i = 1, n = points.Count; i < n; i++)
             {
             }
         }
 
-        public void DrawPolygon(IList<Point> points, IColour colour)
+        public void DrawPolygon(IList<Point> points, IArgb colour)
         {
             for (int i = 1, n = points.Count; i < n; i++)
             {
             this.DrawLine(points[points.Count - 1], points[0], colour);
         }
 
-        public void DrawRectangle(Rectangle rectangle, IColour colour)
+        public void DrawRectangle(Rectangle rectangle, IArgb colour)
         {
             this.DrawRectangle(rectangle, colour, false);
         }
 
-        public void FloodFill(Point p, IColour colour, float tolerance = 0)
+        public void FloodFill(Point p, IArgb colour, float tolerance = 0)
         {
             this.FloodFill(p, this.frame.GetPixel(p), colour, tolerance);
         }
 
-        public void FloodFill(int x, int y, IColour colour, float tolerance = 0)
+        public void FloodFill(int x, int y, IArgb colour, float tolerance = 0)
         {
             this.FloodFill(new Point(x, y), colour, tolerance);
         }
 
         #region Private Static Methods
 
-        private static bool AreColoursEqual(IColour c1, IColour c2, float tolerance)
+        private static bool AreColoursEqual(IArgb c1, IArgb c2, float tolerance)
         {
             if (c1.Equals(c2))
             {
 
         #region Private Methods
 
-        private void DrawCircle(Point pos, int radius, IColour colour, bool filled)
+        private void DrawCircle(Point pos, int radius, IArgb colour, bool filled)
         {
             int x0 = pos.X;
             int y0 = pos.Y;
             }
         }
 
-        private void DrawEllipse(Point pos, int radiusX, int radiusY, IColour colour, bool filled)
+        private void DrawEllipse(Point pos, int radiusX, int radiusY, IArgb colour, bool filled)
         {
             int x0 = pos.X;
             int y0 = pos.Y;
             }
         }
 
-        private void DrawRectangle(Rectangle rectangle, IColour colour, bool filled)
+        private void DrawRectangle(Rectangle rectangle, IArgb colour, bool filled)
         {
             int left = rectangle.Left;
             int top = rectangle.Top;
             }
         }
 
-        private void FloodFill(Point p, IColour targetColour, IColour destColour, float tolerance)
+        private void FloodFill(Point p, IArgb targetColour, IArgb destColour, float tolerance)
         {
             tolerance = tolerance.Clamp(0, 1);
 
             }
         }
 
-        private void SetPixel(Point p, IColour pixel)
+        private void SetPixel(Point p, IArgb pixel)
         {
             this.SetPixel(p.X, p.Y, pixel);
         }
 
-        private void SetPixel(int x, int y, IColour pixel)
+        private void SetPixel(int x, int y, IArgb pixel)
         {
             if (x < 0 || x >= width || y < 0 || y >= height)
             {

SharpImage/ExtensionMethods.cs

 
         #region Public Static Methods
 
-        public static void GetHsv(this IColour self, out float h, out float s, out float v)
+        public static void GetHsv(this IArgb self, out float h, out float s, out float v)
         {
             ColourTools.RgbToHsv(self.R, self.G, self.B, out h, out s, out v);
         }

SharpImage/Filters/Colour/GradientColourising.cs

 
         #region Constructors
 
-        public GradientColourise(IColour firstColour, IColour lastColour)
+        public GradientColourise(IArgb firstColour, IArgb lastColour)
         {
             this.palette = new Palette();
             for (int i = 0; i < 256; i++)

SharpImage/Filters/Transformation/MatrixTransform.cs

         {
         }
 
-        public MatrixTransform(Matrix matrix, IColour fillColour)
+        public MatrixTransform(Matrix matrix, IArgb fillColour)
         {
             this.matrix = matrix;
             this.FillColour = fillColour;
 
         #region Public Properties
 
-        public IColour FillColour
+        public IArgb FillColour
         {
             get;
             private set;

SharpImage/Filters/Transformation/RotateBase.cs

 
         #region Constructors
 
-        protected RotateBase(double angle, bool keepSize, IColour fillColour)
+        protected RotateBase(double angle, bool keepSize, IArgb fillColour)
         {
             this.Angle = angle % 360;
             this.keepSize = keepSize;
             private set;
         }
 
-        public IColour FillColour
+        public IArgb FillColour
         {
             get;
             private set;

SharpImage/Filters/Transformation/RotateBilinear.cs

         {
         }
 
-        public RotateBilinear(double angle, bool keepSize, IColour fillColour)
+        public RotateBilinear(double angle, bool keepSize, IArgb fillColour)
             : base(angle, keepSize, fillColour)
         {
         }

SharpImage/Filters/Transformation/RotateNearestNeighbour.cs

         {
         }
 
-        public RotateNearestNeighbour(double angle, bool keepSize, IColour fillColour)
+        public RotateNearestNeighbour(double angle, bool keepSize, IArgb fillColour)
             : base(angle, keepSize, fillColour)
         {
         }

SharpImage/Frame.cs

             return CreateEmpty(size.Width, size.Height, format);
         }
 
-        public static Frame CreateEmpty(Size size, IEnumerable<IColour> palette, PixelFormat format)
+        public static Frame CreateEmpty(Size size, IEnumerable<IArgb> palette, PixelFormat format)
         {
             return CreateEmpty(size.Width, size.Height, palette, format);
         }
 
-        public static Frame CreateEmpty(int width, int height, IEnumerable<IColour> palette, PixelFormat format)
+        public static Frame CreateEmpty(int width, int height, IEnumerable<IArgb> palette, PixelFormat format)
         {
             var retValue = CreateEmpty(width, height, format);
             if (palette != null)
             return uniqueValues.Count;
         }
 
-        public IColour GetPixel(Point p)
+        public IArgb GetPixel(Point p)
         {
             return this.GetPixel(p.X, p.Y);
         }
 
-        public IColour GetPixel(int x, int y)
+        public IArgb GetPixel(int x, int y)
         {
             var buffer = this.Buffer;
             if (x < 0 || x >= this.width)
             }
         }
 
-        public void SetPixel(Point p, IColour colour)
+        public void SetPixel(Point p, IArgb colour)
         {
             this.SetPixel(p.X, p.Y, colour);
         }
 
-        public void SetPixel(int x, int y, IColour colour)
+        public void SetPixel(int x, int y, IArgb colour)
         {
             if (colour == null)
             {

SharpImage/Palette.cs

 
     using SharpImage.Data;
 
-    public class Palette : IList<IColour>, ICloneable
+    public class Palette : IList<IArgb>, ICloneable
     {
         #region Fields
 
-        private List<IColour> items;
+        private List<IArgb> items;
 
         #endregion Fields
 
 
         public Palette()
         {
-            this.items = new List<IColour>();
+            this.items = new List<IArgb>();
         }
 
-        public Palette(params IColour[] colours)
-            : this((IEnumerable<IColour>)colours)
+        public Palette(params IArgb[] colours)
+            : this((IEnumerable<IArgb>)colours)
         {
         }
 
-        public Palette(IEnumerable<IColour> colours)
+        public Palette(IEnumerable<IArgb> colours)
         {
             if (colours != null)
             {
-                this.items = new List<IColour>(colours);
+                this.items = new List<IArgb>(colours);
             }
             else
             {
-                this.items = new List<IColour>();
+                this.items = new List<IArgb>();
             }
         }
 
 
         #region Indexers
 
-        public IColour this[int index]
+        public IArgb this[int index]
         {
             get
             {
 
         #region Public Methods
 
-        public void Add(IColour item)
+        public void Add(IArgb item)
         {
             this.items.Add(item);
         }
 
-        public void AddRange(params IColour[] items)
+        public void AddRange(params IArgb[] items)
         {
             this.items.AddRange(items);
         }
             return new Palette(this.items);
         }
 
-        public bool Contains(IColour item)
+        public bool Contains(IArgb item)
         {
             return this.items.Contains(item);
         }
 
-        public void CopyTo(IColour[] array, int arrayIndex)
+        public void CopyTo(IArgb[] array, int arrayIndex)
         {
             this.items.CopyTo(array, arrayIndex);
         }
 
-        public int FindNearestIndex(IColour pixel)
+        public int FindNearestIndex(IArgb pixel)
         {
             return this.FindNearestIndex(pixel.A, pixel.R, pixel.G, pixel.B);
         }
             return bestIndex;
         }
 
-        public IEnumerator<IColour> GetEnumerator()
+        public IEnumerator<IArgb> GetEnumerator()
         {
             return this.items.GetEnumerator();
         }
 
-        public int IndexOf(IColour item)
+        public int IndexOf(IArgb item)
         {
             return this.items.IndexOf(item);
         }
 
-        public void Insert(int index, IColour item)
+        public void Insert(int index, IArgb item)
         {
             this.items.Insert(index, item);
         }
 
-        public bool Remove(IColour item)
+        public bool Remove(IArgb item)
         {
             return this.items.Remove(item);
         }

SharpImage/Palettes.cs

                 Greyscale.Add(new Rgb888(b, b, b));
             }
 
-            Monochrome = new Palette(new IColour[] { new Rgb888(0, 0, 0), new Rgb888(255, 255, 255) });
+            Monochrome = new Palette(new IArgb[] { new Rgb888(0, 0, 0), new Rgb888(255, 255, 255) });
 
             C64 = new Palette(
                 new Rgb888(0, 0, 0),

SharpImage/SharpImage.csproj

     <Compile Include="Data\Argb4444.cs" />
     <Compile Include="Data\Argb2101010.cs" />
     <Compile Include="Data\Rgb332.cs" />
-    <Compile Include="Data\IColour.cs" />
+    <Compile Include="Data\IArgb.cs" />
     <Compile Include="Data\Rgb555.cs" />
     <Compile Include="Data\Rgb565.cs" />
     <Compile Include="Data\Rgb888.cs" />
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.