Support for the new XML format.

macmade · macmade · commit 7989b611e401 · 2019-11-20T17:14:27.000+01:00
diff --git a/ColorSetKit-Test/ColorSetKit-Test.csproj b/ColorSetKit-Test/ColorSetKit-Test.csproj
@@ -78,6 +78,7 @@
   </Target>
   <Import Project="..\packages\MSTest.TestAdapter.1.3.2\build\net45\MSTest.TestAdapter.targets" Condition="Exists('..\packages\MSTest.TestAdapter.1.3.2\build\net45\MSTest.TestAdapter.targets')" />
   <PropertyGroup>
-    <PostBuildEvent>copy "$(ProjectDir)Colors.colorset" "$(TargetDir)Colors.colorset"</PostBuildEvent>
+    <PostBuildEvent>copy "$(ProjectDir)Colors.colorset" "$(TargetDir)Colors.colorset"
+copy "$(ProjectDir)Colors-XML.colorset" "$(TargetDir)Colors-XML.colorset"</PostBuildEvent>
   </PropertyGroup>
 </Project>
diff --git a/ColorSetKit-Test/Test.cs b/ColorSetKit-Test/Test.cs
@@ -34,7 +34,7 @@ namespace ColorSetKit_Test
     public class Test
     {
         [TestMethod]
-        public void TestInitWithPath()
+        public void TestInitWithPathBinary()
         {
             string path  = System.IO.Path.Combine( System.IO.Path.GetDirectoryName( Assembly.GetExecutingAssembly().Location ), "Colors.colorset" );
             ColorSet set = new ColorSet( path );
@@ -43,7 +43,16 @@ public void TestInitWithPath()
         }
 
         [TestMethod]
-        public void TestInitWithData()
+        public void TestInitWithPathXML()
+        {
+            string path  = System.IO.Path.Combine( System.IO.Path.GetDirectoryName( Assembly.GetExecutingAssembly().Location ), "Colors-XML.colorset" );
+            ColorSet set = new ColorSet( path );
+
+            Assert.IsTrue( set.Colors.Count > 0 );
+        }
+
+        [TestMethod]
+        public void TestInitWithDataBinary()
         {
             string path  = System.IO.Path.Combine( System.IO.Path.GetDirectoryName( Assembly.GetExecutingAssembly().Location ), "Colors.colorset" );
             Data data    = new Data( path );
@@ -52,6 +61,16 @@ public void TestInitWithData()
             Assert.IsTrue( set.Colors.Count > 0 );
         }
 
+        [TestMethod]
+        public void TestInitWithDataXML()
+        {
+            string path  = System.IO.Path.Combine( System.IO.Path.GetDirectoryName( Assembly.GetExecutingAssembly().Location ), "Colors-XML.colorset" );
+            Data data    = new Data( path );
+            ColorSet set = new ColorSet( data );
+
+            Assert.IsTrue( set.Colors.Count > 0 );
+        }
+
         [TestMethod]
         public void TestShared()
         {
diff --git a/ColorSetKit/ColorPair.cs b/ColorSetKit/ColorPair.cs
@@ -71,37 +71,36 @@ public ColorPair( Dictionary< string, object > dictionary ): this()
             }
 
             {
-                if( dictionary.TryGetValue( "color", out object o ) == false || !( o is Dictionary< string, object > dict ) )
+                if( dictionary.TryGetValue( "color", out object o ) && o is Dictionary< string, object > dict )
                 {
-                    throw new ArgumentException();
+                    this.Color = this.ColorFromDictionary( dict );
                 }
-
-                this.Color = this.ColorFromDictionary( dict );
             }
 
             {
-                if( dictionary.TryGetValue( "variant", out object o ) == false || !( o is Dictionary< string, object > dict ) )
+                if( dictionary.TryGetValue( "variant", out object o ) && o is Dictionary< string, object > dict )
                 {
-                    throw new ArgumentException();
+                    this.Variant = this.ColorFromDictionary( dict );
                 }
-
-                this.Variant = this.ColorFromDictionary( dict );
             }
 
             {
-                if( dictionary.TryGetValue( "lightnesses", out object o ) == false || !( o is List< Dictionary< string, object > > list ) )
-                {
-                    throw new ArgumentException();
-                }
-
-                foreach( Dictionary< string, object > l in list )
+                if( dictionary.TryGetValue( "lightnesses", out object o ) && o is List< object > list )
                 {
-                    try
+                    foreach( object value in list )
                     {
-                        this.Lightnesses.Add( new LightnessPair( l ) );
+                        if( !( value is Dictionary<string, object> l ) )
+                        {
+                            continue;
+                        }
+
+                        try
+                        {
+                            this.Lightnesses.Add( new LightnessPair( l ) );
+                        }
+                        catch
+                        {}
                     }
-                    catch
-                    {}
                 }
             }
         }
@@ -133,14 +132,14 @@ private Dictionary< string, object > ColorToDictionary( SolidColorBrush color )
                 return null;
             }
 
-            ColorExtensions.HSLComponents hsl = color.Color.GetHSL();
+            ColorExtensions.RGBComponents rgb = color.Color.GetRGB();
 
             return new Dictionary< string, object >
             {
-                { "h", hsl.Hue },
-                { "s", hsl.Saturation },
-                { "l", hsl.Lightness },
-                { "a", hsl.Alpha }
+                { "r", rgb.Red },
+                { "g", rgb.Green },
+                { "b", rgb.Blue },
+                { "a", rgb.Alpha }
             };
         }
 
@@ -151,36 +150,36 @@ private SolidColorBrush ColorFromDictionary( Dictionary< string, object > dictio
                 return null;
             }
 
-            double h;
-            double s;
-            double l;
+            double r;
+            double g;
+            double b;
             double a;
 
             {
-                if( dictionary.TryGetValue( "h", out object o ) == false || !( o is double d ) )
+                if( dictionary.TryGetValue( "r", out object o ) == false || !( o is double d ) )
                 {
                     throw new ArgumentException();
                 }
 
-                h = d;
+                r = d;
             }
 
             {
-                if( dictionary.TryGetValue( "s", out object o ) == false || !( o is double d ) )
+                if( dictionary.TryGetValue( "g", out object o ) == false || !( o is double d ) )
                 {
                     throw new ArgumentException();
                 }
 
-                s = d;
+                g = d;
             }
 
             {
-                if( dictionary.TryGetValue( "l", out object o ) == false || !( o is double d ) )
+                if( dictionary.TryGetValue( "b", out object o ) == false || !( o is double d ) )
                 {
                     throw new ArgumentException();
                 }
 
-                l = d;
+                b = d;
             }
 
             {
@@ -192,7 +191,16 @@ private SolidColorBrush ColorFromDictionary( Dictionary< string, object > dictio
                 a = d;
             }
 
-            return new SolidColorBrush( ColorExtensions.FromHSL( h, s, l, a ) );
+            return new SolidColorBrush
+            (
+                System.Windows.Media.Color.FromArgb
+                (
+                    ( byte )Math.Round( a * 255 ),
+                    ( byte )Math.Round( r * 255 ),
+                    ( byte )Math.Round( g * 255 ),
+                    ( byte )Math.Round( b * 255 )
+                )
+            );
         }
     }
 }
diff --git a/ColorSetKit/ColorSet.cs b/ColorSetKit/ColorSet.cs
@@ -145,6 +145,13 @@ public ColorSet( Data data )
                 return;
             }
 
+            if( PropertyListSerialization.PropertyListFromData( data ) is Dictionary< string, object > dict )
+            {
+                this.InitFromDictionary( dict );
+                
+                return;
+            }
+
             ColorSetStream stream = new ColorSetStream( data );
 
             if( stream.ReadUInt64() != Magic )
@@ -341,37 +348,37 @@ public Data Data
             }
         }
 
-        public ColorSet( Dictionary< string, object > dictionary ): this()
+        private void InitFromDictionary( Dictionary< string, object > dictionary )
         {
             ulong magic;
             ulong major;
             ulong minor;
 
             {
-                if( dictionary.TryGetValue( "magic", out object o ) == false || !( o is ulong u ) )
+                if( dictionary.TryGetValue( "magic", out object o ) == false || !( o is long u ) )
                 {
                     throw new ArgumentException();
                 }
 
-                magic = u;
+                magic = ( ulong )u;
             }
 
             {
-                if( dictionary.TryGetValue( "major", out object o ) == false || !( o is ulong u ) )
+                if( dictionary.TryGetValue( "major", out object o ) == false || !( o is long u ) )
                 {
                     throw new ArgumentException();
                 }
 
-                major = u;
+                major = ( ulong )u;
             }
 
             {
-                if( dictionary.TryGetValue( "minor", out object o ) == false || !( o is ulong u ) )
+                if( dictionary.TryGetValue( "minor", out object o ) == false || !( o is long u ) )
                 {
                     throw new ArgumentException();
                 }
 
-                minor = u;
+                minor = ( ulong )u;
             }
 
             if( magic != Magic )
@@ -385,13 +392,18 @@ public ColorSet( Dictionary< string, object > dictionary ): this()
             }
 
             {
-                if( dictionary.TryGetValue( "colors", out object o ) && o is Dictionary< string, Dictionary< string, object > > colors )
+                if( dictionary.TryGetValue( "colors", out object o ) && o is Dictionary< string, object > colors )
                 {
-                    foreach( KeyValuePair< string, Dictionary< string, object > > p in colors )
+                    foreach( KeyValuePair< string, object > p in colors )
                     {
+                        if( !( p.Value is Dictionary< string, object > dict ) )
+                        {
+                            continue;
+                        }
+                        
                         try
                         {
-                            this.ColorPairs[ p.Key ] = new ColorPair( p.Value );
+                            this.ColorPairs[ p.Key ] = new ColorPair( dict );
                         }
                         catch
                         {}
diff --git a/ColorSetKit/PropertyListSerialization.cs b/ColorSetKit/PropertyListSerialization.cs
@@ -24,6 +24,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -61,22 +62,20 @@ public static object PropertyListFromData( Data data )
                 {
                     xml.Load( reader );
 
-                    if( xml.ChildNodes.Count != 1 )
+                    foreach( XmlNode child in xml.ChildNodes )
                     {
-                        return null;
-                    }
+                        if( child.Name != "plist" )
+                        {
+                            continue;
+                        }
 
-                    if( xml.FirstChild.Name != "plist" )
-                    {
-                        return null;
-                    }
+                        if( child.ChildNodes.Count != 1 )
+                        {
+                            return null;
+                        }
 
-                    if( xml.FirstChild.ChildNodes.Count != 1 )
-                    {
-                        return null;
+                        return PropertyListFromXmlNode( child.FirstChild );
                     }
-
-                    return PropertyListFromXmlNode( xml.FirstChild.FirstChild );
                 }
             }
             catch
@@ -110,7 +109,7 @@ private static long LongFromXmlNode( XmlNode node )
         {
             try
             {
-                return Convert.ToInt64( node.Value );
+                return long.Parse( node.InnerText, CultureInfo.InvariantCulture );
             }
             catch
             {}
@@ -122,7 +121,7 @@ private static double DoubleFromXmlNode( XmlNode node )
         {
             try
             {
-                return Convert.ToDouble( node.Value );
+                return double.Parse( node.InnerText, CultureInfo.InvariantCulture );
             }
             catch
             {}
@@ -166,7 +165,7 @@ private static Dictionary< string, object > DictionaryFromXmlNode( XmlNode node
                 {
                     if( child.Name == "key" )
                     {
-                        key = child.Value;
+                        key = child.InnerText;
 
                         continue;
                     }

Original file line number	Diff line number	Diff line change
`@@ -71,37 +71,36 @@ public ColorPair( Dictionary< string, object > dictionary ): this()`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`{`
`74`		`- if( dictionary.TryGetValue( "color", out object o ) == false \|\| !( o is Dictionary< string, object > dict ) )`
	`74`	`+ if( dictionary.TryGetValue( "color", out object o ) && o is Dictionary< string, object > dict )`
`75`	`75`	`{`
`76`		`- throw new ArgumentException();`
	`76`	`+ this.Color = this.ColorFromDictionary( dict );`
`77`	`77`	`}`
`78`		`-`
`79`		`- this.Color = this.ColorFromDictionary( dict );`
`80`	`78`	`}`
`81`	`79`
`82`	`80`	`{`
`83`		`- if( dictionary.TryGetValue( "variant", out object o ) == false \|\| !( o is Dictionary< string, object > dict ) )`
	`81`	`+ if( dictionary.TryGetValue( "variant", out object o ) && o is Dictionary< string, object > dict )`
`84`	`82`	`{`
`85`		`- throw new ArgumentException();`
	`83`	`+ this.Variant = this.ColorFromDictionary( dict );`
`86`	`84`	`}`
`87`		`-`
`88`		`- this.Variant = this.ColorFromDictionary( dict );`
`89`	`85`	`}`
`90`	`86`
`91`	`87`	`{`
`92`		`- if( dictionary.TryGetValue( "lightnesses", out object o ) == false \|\| !( o is List< Dictionary< string, object > > list ) )`
`93`		`- {`
`94`		`- throw new ArgumentException();`
`95`		`- }`
`96`		`-`
`97`		`- foreach( Dictionary< string, object > l in list )`
	`88`	`+ if( dictionary.TryGetValue( "lightnesses", out object o ) && o is List< object > list )`
`98`	`89`	`{`
`99`		`- try`
	`90`	`+ foreach( object value in list )`
`100`	`91`	`{`
`101`		`- this.Lightnesses.Add( new LightnessPair( l ) );`
	`92`	`+ if( !( value is Dictionary<string, object> l ) )`
	`93`	`+ {`
	`94`	`+ continue;`
	`95`	`+ }`
	`96`	`+`
	`97`	`+ try`
	`98`	`+ {`
	`99`	`+ this.Lightnesses.Add( new LightnessPair( l ) );`
	`100`	`+ }`
	`101`	`+ catch`
	`102`	`+ {}`
`102`	`103`	`}`
`103`		`- catch`
`104`		`- {}`
`105`	`104`	`}`
`106`	`105`	`}`
`107`	`106`	`}`
`@@ -133,14 +132,14 @@ private Dictionary< string, object > ColorToDictionary( SolidColorBrush color )`
`133`	`132`	`return null;`
`134`	`133`	`}`
`135`	`134`
`136`		`- ColorExtensions.HSLComponents hsl = color.Color.GetHSL();`
	`135`	`+ ColorExtensions.RGBComponents rgb = color.Color.GetRGB();`
`137`	`136`
`138`	`137`	`return new Dictionary< string, object >`
`139`	`138`	`{`
`140`		`- { "h", hsl.Hue },`
`141`		`- { "s", hsl.Saturation },`
`142`		`- { "l", hsl.Lightness },`
`143`		`- { "a", hsl.Alpha }`
	`139`	`+ { "r", rgb.Red },`
	`140`	`+ { "g", rgb.Green },`
	`141`	`+ { "b", rgb.Blue },`
	`142`	`+ { "a", rgb.Alpha }`
`144`	`143`	`};`
`145`	`144`	`}`
`146`	`145`
`@@ -151,36 +150,36 @@ private SolidColorBrush ColorFromDictionary( Dictionary< string, object > dictio`
`151`	`150`	`return null;`
`152`	`151`	`}`
`153`	`152`
`154`		`- double h;`
`155`		`- double s;`
`156`		`- double l;`
	`153`	`+ double r;`
	`154`	`+ double g;`
	`155`	`+ double b;`
`157`	`156`	`double a;`
`158`	`157`
`159`	`158`	`{`
`160`		`- if( dictionary.TryGetValue( "h", out object o ) == false \|\| !( o is double d ) )`
	`159`	`+ if( dictionary.TryGetValue( "r", out object o ) == false \|\| !( o is double d ) )`
`161`	`160`	`{`
`162`	`161`	`throw new ArgumentException();`
`163`	`162`	`}`
`164`	`163`
`165`		`- h = d;`
	`164`	`+ r = d;`
`166`	`165`	`}`
`167`	`166`
`168`	`167`	`{`
`169`		`- if( dictionary.TryGetValue( "s", out object o ) == false \|\| !( o is double d ) )`
	`168`	`+ if( dictionary.TryGetValue( "g", out object o ) == false \|\| !( o is double d ) )`
`170`	`169`	`{`
`171`	`170`	`throw new ArgumentException();`
`172`	`171`	`}`
`173`	`172`
`174`		`- s = d;`
	`173`	`+ g = d;`
`175`	`174`	`}`
`176`	`175`
`177`	`176`	`{`
`178`		`- if( dictionary.TryGetValue( "l", out object o ) == false \|\| !( o is double d ) )`
	`177`	`+ if( dictionary.TryGetValue( "b", out object o ) == false \|\| !( o is double d ) )`
`179`	`178`	`{`
`180`	`179`	`throw new ArgumentException();`
`181`	`180`	`}`
`182`	`181`
`183`		`- l = d;`
	`182`	`+ b = d;`
`184`	`183`	`}`
`185`	`184`
`186`	`185`	`{`
`@@ -192,7 +191,16 @@ private SolidColorBrush ColorFromDictionary( Dictionary< string, object > dictio`
`192`	`191`	`a = d;`
`193`	`192`	`}`
`194`	`193`
`195`		`- return new SolidColorBrush( ColorExtensions.FromHSL( h, s, l, a ) );`
	`194`	`+ return new SolidColorBrush`
	`195`	`+ (`
	`196`	`+ System.Windows.Media.Color.FromArgb`
	`197`	`+ (`
	`198`	`+ ( byte )Math.Round( a * 255 ),`
	`199`	`+ ( byte )Math.Round( r * 255 ),`
	`200`	`+ ( byte )Math.Round( g * 255 ),`
	`201`	`+ ( byte )Math.Round( b * 255 )`
	`202`	`+ )`
	`203`	`+ );`
`196`	`204`	`}`
`197`	`205`	`}`
`198`	`206`	`}`
Original file line number	Diff line number	Diff line change
`@@ -145,6 +145,13 @@ public ColorSet( Data data )`
`145`	`145`	`return;`
`146`	`146`	`}`
`147`	`147`
	`148`	`+ if( PropertyListSerialization.PropertyListFromData( data ) is Dictionary< string, object > dict )`
	`149`	`+ {`
	`150`	`+ this.InitFromDictionary( dict );`
	`151`	`+`
	`152`	`+ return;`
	`153`	`+ }`
	`154`	`+`
`148`	`155`	`ColorSetStream stream = new ColorSetStream( data );`
`149`	`156`
`150`	`157`	`if( stream.ReadUInt64() != Magic )`
`@@ -341,37 +348,37 @@ public Data Data`
`341`	`348`	`}`
`342`	`349`	`}`
`343`	`350`
`344`		`- public ColorSet( Dictionary< string, object > dictionary ): this()`
	`351`	`+ private void InitFromDictionary( Dictionary< string, object > dictionary )`
`345`	`352`	`{`
`346`	`353`	`ulong magic;`
`347`	`354`	`ulong major;`
`348`	`355`	`ulong minor;`
`349`	`356`
`350`	`357`	`{`
`351`		`- if( dictionary.TryGetValue( "magic", out object o ) == false \|\| !( o is ulong u ) )`
	`358`	`+ if( dictionary.TryGetValue( "magic", out object o ) == false \|\| !( o is long u ) )`
`352`	`359`	`{`
`353`	`360`	`throw new ArgumentException();`
`354`	`361`	`}`
`355`	`362`
`356`		`- magic = u;`
	`363`	`+ magic = ( ulong )u;`
`357`	`364`	`}`
`358`	`365`
`359`	`366`	`{`
`360`		`- if( dictionary.TryGetValue( "major", out object o ) == false \|\| !( o is ulong u ) )`
	`367`	`+ if( dictionary.TryGetValue( "major", out object o ) == false \|\| !( o is long u ) )`
`361`	`368`	`{`
`362`	`369`	`throw new ArgumentException();`
`363`	`370`	`}`
`364`	`371`
`365`		`- major = u;`
	`372`	`+ major = ( ulong )u;`
`366`	`373`	`}`
`367`	`374`
`368`	`375`	`{`
`369`		`- if( dictionary.TryGetValue( "minor", out object o ) == false \|\| !( o is ulong u ) )`
	`376`	`+ if( dictionary.TryGetValue( "minor", out object o ) == false \|\| !( o is long u ) )`
`370`	`377`	`{`
`371`	`378`	`throw new ArgumentException();`
`372`	`379`	`}`
`373`	`380`
`374`		`- minor = u;`
	`381`	`+ minor = ( ulong )u;`
`375`	`382`	`}`
`376`	`383`
`377`	`384`	`if( magic != Magic )`
`@@ -385,13 +392,18 @@ public ColorSet( Dictionary< string, object > dictionary ): this()`
`385`	`392`	`}`
`386`	`393`
`387`	`394`	`{`
`388`		`- if( dictionary.TryGetValue( "colors", out object o ) && o is Dictionary< string, Dictionary< string, object > > colors )`
	`395`	`+ if( dictionary.TryGetValue( "colors", out object o ) && o is Dictionary< string, object > colors )`
`389`	`396`	`{`
`390`		`- foreach( KeyValuePair< string, Dictionary< string, object > > p in colors )`
	`397`	`+ foreach( KeyValuePair< string, object > p in colors )`
`391`	`398`	`{`
	`399`	`+ if( !( p.Value is Dictionary< string, object > dict ) )`
	`400`	`+ {`
	`401`	`+ continue;`
	`402`	`+ }`
	`403`	`+`
`392`	`404`	`try`
`393`	`405`	`{`
`394`		`- this.ColorPairs[ p.Key ] = new ColorPair( p.Value );`
	`406`	`+ this.ColorPairs[ p.Key ] = new ColorPair( dict );`
`395`	`407`	`}`
`396`	`408`	`catch`
`397`	`409`	`{}`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@`
`24`	`24`
`25`	`25`	`using System;`
`26`	`26`	`using System.Collections.Generic;`
	`27`	`+using System.Globalization;`
`27`	`28`	`using System.IO;`
`28`	`29`	`using System.Linq;`
`29`	`30`	`using System.Text;`
`@@ -61,22 +62,20 @@ public static object PropertyListFromData( Data data )`
`61`	`62`	`{`
`62`	`63`	`xml.Load( reader );`
`63`	`64`
`64`		`- if( xml.ChildNodes.Count != 1 )`
	`65`	`+ foreach( XmlNode child in xml.ChildNodes )`
`65`	`66`	`{`
`66`		`- return null;`
`67`		`- }`
	`67`	`+ if( child.Name != "plist" )`
	`68`	`+ {`
	`69`	`+ continue;`
	`70`	`+ }`
`68`	`71`
`69`		`- if( xml.FirstChild.Name != "plist" )`
`70`		`- {`
`71`		`- return null;`
`72`		`- }`
	`72`	`+ if( child.ChildNodes.Count != 1 )`
	`73`	`+ {`
	`74`	`+ return null;`
	`75`	`+ }`
`73`	`76`
`74`		`- if( xml.FirstChild.ChildNodes.Count != 1 )`
`75`		`- {`
`76`		`- return null;`
	`77`	`+ return PropertyListFromXmlNode( child.FirstChild );`
`77`	`78`	`}`
`78`		`-`
`79`		`- return PropertyListFromXmlNode( xml.FirstChild.FirstChild );`
`80`	`79`	`}`
`81`	`80`	`}`
`82`	`81`	`catch`
`@@ -110,7 +109,7 @@ private static long LongFromXmlNode( XmlNode node )`
`110`	`109`	`{`
`111`	`110`	`try`
`112`	`111`	`{`
`113`		`- return Convert.ToInt64( node.Value );`
	`112`	`+ return long.Parse( node.InnerText, CultureInfo.InvariantCulture );`
`114`	`113`	`}`
`115`	`114`	`catch`
`116`	`115`	`{}`
`@@ -122,7 +121,7 @@ private static double DoubleFromXmlNode( XmlNode node )`
`122`	`121`	`{`
`123`	`122`	`try`
`124`	`123`	`{`
`125`		`- return Convert.ToDouble( node.Value );`
	`124`	`+ return double.Parse( node.InnerText, CultureInfo.InvariantCulture );`
`126`	`125`	`}`
`127`	`126`	`catch`
`128`	`127`	`{}`
`@@ -166,7 +165,7 @@ private static Dictionary< string, object > DictionaryFromXmlNode( XmlNode node`
`166`	`165`	`{`
`167`	`166`	`if( child.Name == "key" )`
`168`	`167`	`{`
`169`		`- key = child.Value;`
	`168`	`+ key = child.InnerText;`
`170`	`169`
`171`	`170`	`continue;`
`172`	`171`	`}`