Added parsing all known for now types of parameters

WatchFace/Elements/Activity.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
-using WatchFace.BasicElements;
+using WatchFace.Elements.ActivityElements;
+using WatchFace.Elements.BasicElements;
 using WatchFace.Models;
 
 namespace WatchFace.Elements

WatchFace/Elements/ActivityElements/FormattedNumber.cs

@@ -1,13 +1,13 @@
 using System;
 using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
 using WatchFace.Models;
 
-namespace WatchFace.BasicElements
+namespace WatchFace.Elements.ActivityElements
 {
     public class FormattedNumber
     {
         public Number Number { get; set; }
-
         public long SuffixImageIndex { get; set; }
         public long DecimalPointImageIndex { get; set; }
 

WatchFace/Elements/AnalogDialFace.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements
+{
+    public class AnalogDialFace
+    {
+        public ClockHand Hours { get; set; }
+        public ClockHand Minutes { get; set; }
+        public ClockHand Seconds { get; set; }
+
+        public static AnalogDialFace Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new AnalogDialFace();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Hours = ClockHand.Parse(parameter.Children);
+                        break;
+                    case 2:
+                        result.Minutes = ClockHand.Parse(parameter.Children);
+                        break;
+                    case 3:
+                        result.Seconds = ClockHand.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/Background.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
 using WatchFace.Models;
 
 namespace WatchFace.Elements

WatchFace/Elements/BasicElements/ClockHand.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.BasicElements
+{
+    public class ClockHand
+    {
+        public long Unknown { get; set; }
+        public long Color { get; set; }
+        public Coordinates Center { get; set; }
+        public List<Coordinates> Shape { get; set; }
+        public Image CenterImage { get; set; }
+
+        public static ClockHand Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new ClockHand {Shape = new List<Coordinates>()};
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Unknown = parameter.Value;
+                        break;
+                    case 2:
+                        result.Color = parameter.Value;
+                        break;
+                    case 3:
+                        result.Center = Coordinates.Parse(parameter.Children);
+                        break;
+                    case 4:
+                        result.Shape.Add(Coordinates.Parse(parameter.Children));
+                        break;
+                    case 5:
+                        result.CenterImage = Image.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/BasicElements/Coordinates.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.BasicElements
+{
+    public class Coordinates
+    {
+        public long X { get; set; }
+        public long Y { get; set; }
+
+        public static Coordinates Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new Coordinates();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.X = parameter.Value;
+                        break;
+                    case 2:
+                        result.Y = parameter.Value;
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/BasicElements/Image.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using WatchFace.Models;
 
-namespace WatchFace.Elements
+namespace WatchFace.Elements.BasicElements
 {
     public class Image
     {

WatchFace/Elements/BasicElements/ImageSet.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using WatchFace.Models;
 
-namespace WatchFace.BasicElements
+namespace WatchFace.Elements.BasicElements
 {
     public class ImageSet
     {

WatchFace/Elements/BasicElements/Number.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using WatchFace.Models;
 
-namespace WatchFace.BasicElements
+namespace WatchFace.Elements.BasicElements
 {
     public class Number
     {

WatchFace/Elements/BasicElements/Scale.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.BasicElements
+{
+    public class Scale
+    {
+        public long StartImageIndex { get; set; }
+        public List<Coordinates> Segments { get; set; }
+
+        public static Scale Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new Scale {Segments = new List<Coordinates>()};
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.StartImageIndex = parameter.Value;
+                        break;
+                    case 2:
+                        result.Segments.Add(Coordinates.Parse(parameter.Children));
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/BasicElements/TwoDigits.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using WatchFace.Models;
 
-namespace WatchFace.BasicElements
+namespace WatchFace.Elements.BasicElements
 {
     public class TwoDigits
     {

WatchFace/Elements/Battery.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements
+{
+    public class Battery
+    {
+        public Number Text { get; set; }
+        public ImageSet Icon { get; set; }
+
+        public static Battery Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new Battery();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Text = Number.Parse(parameter.Children);
+                        break;
+                    case 2:
+                        result.Icon = ImageSet.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/Date.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
-using WatchFace.BasicElements;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Elements.DateElements;
 using WatchFace.Models;
 
 namespace WatchFace.Elements

WatchFace/Elements/DateElements/MonthAndDay.cs

@@ -1,14 +1,13 @@
 using System;
 using System.Collections.Generic;
-using WatchFace.BasicElements;
 using WatchFace.Models;
 
-namespace WatchFace.Elements
+namespace WatchFace.Elements.DateElements
 {
     public class MonthAndDay
     {
         public SeparateMonthAndDay Separate { get; set; }
-        public JoinedNumber Joined { get; set; }
+        public OneLineMonthAndDay Joined { get; set; }
         public long Unknown1 { get; set; }
         public long Unknown2 { get; set; }
 
@@ -25,7 +24,7 @@ namespace WatchFace.Elements
                         result.Separate = SeparateMonthAndDay.Parse(parameter.Children);
                         break;
                     case 2:
-                        result.Joined = JoinedNumber.Parse(parameter.Children);
+                        result.Joined = OneLineMonthAndDay.Parse(parameter.Children);
                         break;
                     case 3:
                         result.Unknown1 = parameter.Value;

WatchFace/Elements/DateElements/OneLineMonthAndDay.cs

@@ -1,20 +1,21 @@
 using System;
 using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
 using WatchFace.Models;
 
-namespace WatchFace.BasicElements
+namespace WatchFace.Elements.DateElements
 {
-    public class JoinedNumber
+    public class OneLineMonthAndDay
     {
         public Number Number { get; set; }
         public long DelimiterImageIndex { get; set; }
 
-        public static JoinedNumber Parse(List<Parameter> descriptor)
+        public static OneLineMonthAndDay Parse(List<Parameter> descriptor)
         {
             if (descriptor == null)
                 throw new ArgumentNullException(nameof(descriptor));
 
-            var result = new JoinedNumber();
+            var result = new OneLineMonthAndDay();
             foreach (var parameter in descriptor)
                 switch (parameter.Id)
                 {

WatchFace/Elements/DateElements/SeparateMonthAndDay.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
-using WatchFace.BasicElements;
+using WatchFace.Elements.BasicElements;
 using WatchFace.Models;
 
-namespace WatchFace.Elements
+namespace WatchFace.Elements.DateElements
 {
     public class SeparateMonthAndDay
     {

WatchFace/Elements/Scales.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements
+{
+    public class Scales
+    {
+        public Scale Steps { get; set; }
+
+        public static Scales Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new Scales();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 2:
+                        result.Steps = Scale.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/Status.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.StatusElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements
+{
+    public class Status
+    {
+        public Switch Switch { get; set; }
+        public Flag Alarm { get; set; }
+        public Flag Lock { get; set; }
+        public Flag DoNotDisturb { get; set; }
+
+        public static Status Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new Status();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Switch = Switch.Parse(parameter.Children);
+                        break;
+                    case 2:
+                        result.Alarm = Flag.Parse(parameter.Children);
+                        break;
+                    case 3:
+                        result.Lock = Flag.Parse(parameter.Children);
+                        break;
+                    case 4:
+                        result.DoNotDisturb = Flag.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/StatusElements/Flag.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.StatusElements
+{
+    public class Flag
+    {
+        public long ImageIndexOn { get; set; }
+        public Coordinates Coordinates { get; set; }
+
+        public static Flag Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new Flag();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Coordinates = Coordinates.Parse(parameter.Children);
+                        break;
+                    case 2:
+                        result.ImageIndexOn = parameter.Value;
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/StatusElements/Switch.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.StatusElements
+{
+    public class Switch
+    {
+        public long ImageIndexOn { get; set; }
+        public long ImageIndexOff { get; set; }
+        public Coordinates Coordinates { get; set; }
+
+        public static Switch Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new Switch();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Coordinates = Coordinates.Parse(parameter.Children);
+                        break;
+                    case 2:
+                        result.ImageIndexOn = parameter.Value;
+                        break;
+                    case 3:
+                        result.ImageIndexOff = parameter.Value;
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/Time.cs

@@ -1,13 +1,14 @@
 using System;
 using System.Collections.Generic;
-using WatchFace.BasicElements;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Elements.TimeElements;
 using WatchFace.Models;
 
 namespace WatchFace.Elements
 {
     public class Time
     {
-        public AmPmSwitch AmPm { get; set; }
+        public AmPm AmPm { get; set; }
         public TwoDigits Hours { get; set; }
         public TwoDigits Minutes { get; set; }
         public TwoDigits Seconds { get; set; }
@@ -31,7 +32,7 @@ namespace WatchFace.Elements
                         result.Seconds = TwoDigits.Parse(parameter.Children);
                         break;
                     case 4:
-                        result.AmPm = AmPmSwitch.Parse(parameter.Children);
+                        result.AmPm = AmPm.Parse(parameter.Children);
                         break;
                     default:
                         throw new InvalidParameterException(parameter);

WatchFace/Elements/TimeElements/AmPm.cs

@@ -2,21 +2,21 @@
 using System.Collections.Generic;
 using WatchFace.Models;
 
-namespace WatchFace.BasicElements
+namespace WatchFace.Elements.TimeElements
 {
-    public class AmPmSwitch
+    public class AmPm
     {
         public long ImageIndexPm { get; set; }
         public long ImageIndexAm { get; set; }
         public long X { get; set; }
         public long Y { get; set; }
 
-        public static AmPmSwitch Parse(List<Parameter> descriptor)
+        public static AmPm Parse(List<Parameter> descriptor)
         {
             if (descriptor == null)
                 throw new ArgumentNullException(nameof(descriptor));
 
-            var result = new AmPmSwitch();
+            var result = new AmPm();
             foreach (var parameter in descriptor)
                 switch (parameter.Id)
                 {

WatchFace/Elements/Weather.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.WeatherElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements
+{
+    public class Weather
+    {
+        public WeatherIcon Icon { get; set; }
+        public Temperature Temperature { get; set; }
+        public AirPollution AirPollution { get; set; }
+
+        public static Weather Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new Weather();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Icon = WeatherIcon.Parse(parameter.Children);
+                        break;
+                    case 2:
+                        result.Temperature = Temperature.Parse(parameter.Children);
+                        break;
+                    case 3:
+                        result.AirPollution = AirPollution.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/WeatherElements/AirPollution.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.WeatherElements
+{
+    public class AirPollution
+    {
+        public ImageSet Icon { get; set; }
+
+        public static AirPollution Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new AirPollution();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 2:
+                        result.Icon = ImageSet.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/WeatherElements/JoinedTemperature.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.WeatherElements
+{
+    public class JoinedTemperature
+    {
+        public Number Number { get; set; }
+        public long MinusSignImageIndex { get; set; }
+        public long DelimiterImageIndex { get; set; }
+        public long Unknown { get; set; }
+        public long DegreesImageIndex { get; set; }
+
+        public static JoinedTemperature Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new JoinedTemperature();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Number = Number.Parse(parameter.Children);
+                        break;
+                    case 2:
+                        result.MinusSignImageIndex = parameter.Value;
+                        break;
+                    case 3:
+                        result.DelimiterImageIndex = parameter.Value;
+                        break;
+                    case 4:
+                        result.Unknown = parameter.Value;
+                        break;
+                    case 5:
+                        result.DegreesImageIndex = parameter.Value;
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/WeatherElements/SeparateTemperature.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.WeatherElements
+{
+    public class SeparateTemperature
+    {
+        public SignedNumber Day { get; set; }
+        public SignedNumber Night { get; set; }
+
+        public static SeparateTemperature Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new SeparateTemperature();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Day = SignedNumber.Parse(parameter.Children);
+                        break;
+                    case 2:
+                        result.Night = SignedNumber.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/WeatherElements/SignedNumber.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.WeatherElements
+{
+    public class SignedNumber
+    {
+        public Number Number { get; set; }
+        public long MinusImageIndex { get; set; }
+
+        public static SignedNumber Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new SignedNumber();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Number = Number.Parse(parameter.Children);
+                        break;
+                    case 2:
+                        result.MinusImageIndex = parameter.Value;
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/WeatherElements/Temperature.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.WeatherElements
+{
+    public class Temperature
+    {
+        public TextTemperature Text { get; set; }
+
+        public static Temperature Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new Temperature();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 2:
+                        result.Text = TextTemperature.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/WeatherElements/TextTemperature.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.WeatherElements
+{
+    public class TextTemperature
+    {
+        public SeparateTemperature Separate { get; set; }
+        public JoinedTemperature Joined { get; set; }
+
+        public static TextTemperature Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new TextTemperature();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Separate = SeparateTemperature.Parse(parameter.Children);
+                        break;
+                    case 2:
+                        result.Joined = JoinedTemperature.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/Elements/WeatherElements/WeatherIcon.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using WatchFace.Elements.BasicElements;
+using WatchFace.Models;
+
+namespace WatchFace.Elements.WeatherElements
+{
+    public class WeatherIcon
+    {
+        public Coordinates Coordinates { get; set; }
+
+        public static WeatherIcon Parse(List<Parameter> descriptor)
+        {
+            if (descriptor == null)
+                throw new ArgumentNullException(nameof(descriptor));
+
+            var result = new WeatherIcon();
+            foreach (var parameter in descriptor)
+                switch (parameter.Id)
+                {
+                    case 1:
+                        result.Coordinates = Coordinates.Parse(parameter.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(parameter);
+                }
+            return result;
+        }
+    }
+}

WatchFace/WatchFace.cs

@@ -7,10 +7,15 @@ namespace WatchFace
 {
     public class WatchFace
     {
-        public Background Background { get; private set; }
-        public Time Time { get; private set; }
-        public Date Date { get; private set; }
-        public Activity Activity { get; private set; }
+        public Background Background { get; set; }
+        public Time Time { get; set; }
+        public Date Date { get; set; }
+        public Weather Weather { get; set; }
+        public Activity Activity { get; set; }
+        public Scales Scales { get; set; }
+        public Status Status { get; set; }
+        public Battery Battery { get; set; }
+        public AnalogDialFace AnalogDialFace { get; set; }
 
         public static WatchFace Parse(List<Parameter> descriptor)
         {
@@ -34,8 +39,23 @@ namespace WatchFace
                     case 5:
                         result.Date = Date.Parse(resource.Children);
                         break;
-                    //default:
-                    //    throw new InvalidParameterException(resource);
+                    case 6:
+                        result.Weather = Weather.Parse(resource.Children);
+                        break;
+                    case 7:
+                        result.Scales = Scales.Parse(resource.Children);
+                        break;
+                    case 8:
+                        result.Status = Status.Parse(resource.Children);
+                        break;
+                    case 9:
+                        result.Battery = Battery.Parse(resource.Children);
+                        break;
+                    case 10:
+                        result.AnalogDialFace = AnalogDialFace.Parse(resource.Children);
+                        break;
+                    default:
+                        throw new InvalidParameterException(resource);
                 }
             return result;
         }

WatchFace/WatchFace.csproj

@@ -15,7 +15,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Folder Include="Parsers\" />
+    <Folder Include="Elements\AnalogDialFaceElements\" />
   </ItemGroup>
 
 </Project>