Fix time calculations. Improved 7-segment display code

Author: BionicCode

BionicCode.Net/BionicCode.Controls.Net.Wpf/BionicCode.Controls.Net.Wpf.csproj.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=clock/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

BionicCode.Net/BionicCode.Controls.Net.Wpf/AnalogClockFace.cs renamed to BionicCode.Net/BionicCode.Controls.Net.Wpf/Clock/AnalogClockFace.cs

@@ -0,0 +1,134 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+
+namespace BionicCode.Controls.Net.Wpf
+{
+  public class Clock : Control
+  {
+    #region Dependency Properties
+
+    #region ClockFace dependency property
+
+    public static readonly DependencyProperty ClockFaceProperty = DependencyProperty.Register(
+      "ClockFace",
+      typeof(ClockFace),
+      typeof(Clock),
+      new PropertyMetadata(default));
+
+    public ClockFace ClockFace { get => (ClockFace) GetValue(Clock.ClockFaceProperty); set => SetValue(Clock.ClockFaceProperty, value); }
+
+    #endregion ClockFace dependency property
+
+    #region CurrentDateTime dependency property
+
+    public static readonly DependencyProperty CurrentDateTimeProperty = DependencyProperty.Register(
+      "CurrentDateTime",
+      typeof(DateTime),
+      typeof(Clock),
+      new PropertyMetadata(default(DateTime), Clock.OnCurrentDateTimeChanged));
+
+    public DateTime CurrentDateTime { get => (DateTime) GetValue(Clock.CurrentDateTimeProperty); set => SetValue(Clock.CurrentDateTimeProperty, value); }
+
+    #endregion CurrentDateTime dependency property
+
+    #region TimeZone dependency property
+
+    public static readonly DependencyProperty TimeZoneProperty = DependencyProperty.Register(
+      "TimeZone",
+      typeof(TimeZoneInfo),
+      typeof(Clock),
+      new PropertyMetadata(TimeZoneInfo.Local));
+
+    public TimeZoneInfo TimeZone { get => (TimeZoneInfo) GetValue(Clock.TimeZoneProperty); set => SetValue(Clock.TimeZoneProperty, value); }
+
+    #endregion TimeZone dependency property
+
+    #region Resolution dependency property
+
+    public static readonly DependencyProperty ResolutionProperty = DependencyProperty.Register(
+      "Resolution",
+      typeof(TimeSpan),
+      typeof(Clock),
+      new PropertyMetadata(TimeSpan.FromSeconds(1)));
+
+    public TimeSpan Resolution { get => (TimeSpan) GetValue(Clock.ResolutionProperty); set => SetValue(Clock.ResolutionProperty, value); }
+
+    #endregion Resolution dependency property
+
+    #region Precision dependency property
+
+    public static readonly DependencyProperty PrecisionProperty = DependencyProperty.Register(
+      "Precision",
+      typeof(TimeSpan),
+      typeof(Clock),
+      new PropertyMetadata(TimeSpan.FromMilliseconds(50)));
+
+    public TimeSpan Precision { get => (TimeSpan) GetValue(Clock.PrecisionProperty); set => SetValue(Clock.PrecisionProperty, value); }
+
+    #endregion Precision dependency property
+
+    #region DispatcherPriority dependency property
+
+    public static readonly DependencyProperty DispatcherPriorityProperty = DependencyProperty.Register(
+      "DispatcherPriority",
+      typeof(DispatcherPriority),
+      typeof(Clock),
+      new PropertyMetadata(System.Windows.Threading.DispatcherPriority.Send));
+
+    public DispatcherPriority DispatcherPriority { get => (DispatcherPriority) GetValue(Clock.DispatcherPriorityProperty); set => SetValue(Clock.DispatcherPriorityProperty, value); }
+
+    #endregion DispatcherPriority dependency property
+
+    #region Meridiem read-only dependency property
+    protected static readonly DependencyPropertyKey MeridiemPropertyKey = DependencyProperty.RegisterReadOnly(
+      "Meridiem",
+      typeof(Meridiem),
+      typeof(Clock),
+      new PropertyMetadata(default(Meridiem)));
+
+    public static readonly DependencyProperty MeridiemProperty = Clock.MeridiemPropertyKey.DependencyProperty;
+
+    public Meridiem Meridiem
+    {
+      get => (Meridiem) GetValue(Clock.MeridiemProperty);
+      private set => SetValue(Clock.MeridiemPropertyKey, value);
+    }
+
+    #endregion Meridiem read-only dependency property
+
+    #endregion Dependency Properties
+
+    public bool IsDaylightSavingTime => this.TimeZone.IsDaylightSavingTime(this.CurrentDateTime);
+
+    private DispatcherTimer Timer { get; }
+
+    static Clock()
+    {
+      FrameworkElement.DefaultStyleKeyProperty
+        .OverrideMetadata(typeof(Clock), new FrameworkPropertyMetadata(typeof(Clock)));
+    }
+
+    public Clock()
+    {
+      this.Timer = new DispatcherTimer(this.Precision, this.DispatcherPriority, OnTimerElapsed, this.Dispatcher);
+    }
+
+    #region OnCurrentDateTimeChanged dependency property changed handler
+
+    private static void OnCurrentDateTimeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) =>
+      (d as Clock).OnCurrentDateTimeChanged((DateTime) e.OldValue, (DateTime) e.NewValue);
+
+    protected virtual void OnCurrentDateTimeChanged(DateTime oldValue, DateTime newValue)
+    {
+      this.Meridiem = newValue.TimeOfDay < new TimeSpan(11, 59, 59)
+        ? Meridiem.AM
+        : Meridiem.PM;
+    }
+
+    #endregion OnCurrentDateTimeChanged dependency property changed handler
+
+    private void OnTimerElapsed(object sender, EventArgs e) => this.CurrentDateTime = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, this.TimeZone);
+  }
+}

BionicCode.Net/BionicCode.Controls.Net.Wpf/Clock/Clock.cs

@@ -275,19 +275,11 @@ private static object CoerceHours(DependencyObject d, object basevalue)
           : Math.Truncate(hourValue) % 12;
       double decimalPart = hourValue - Math.Truncate(hourValue);
       var decimalMinutes = decimalPart * 60;
-      bool isOverflow = decimalMinutes >= 1.0;
-      if (isOverflow)
-      {
-        this_.SelectedMinute = Math.Truncate(decimalMinutes);
-      }
+      this_.SelectedMinute = Math.Truncate(decimalMinutes);
 
       decimalPart = decimalMinutes - Math.Truncate(decimalMinutes);
-      var decimalSeconds = Math.Round(decimalPart * 60, MidpointRounding.AwayFromZero);
-      isOverflow = decimalSeconds >= 1.0;
-      if (isOverflow)
-      {
-        this_.SelectedSecond = decimalSeconds;
-      }
+      var decimalSeconds = Math.Truncate(decimalPart * 60);
+      this_.SelectedSecond = decimalSeconds;
 
       this_.IsUpdatingSelectedTimeComponent = false;
       return hours;
@@ -305,26 +297,18 @@ private static object CoerceMinutes(DependencyObject d, object basevalue)
       this_.IsUpdatingSelectedTimeComponent = true;
       var minuteValue = (double) basevalue;
       double decimalHours = minuteValue / 60;
-      bool isOverflow = decimalHours >= 1.0;
-      if (isOverflow)
-      {
-        this_.SelectedHour = this_.Is24HModeEnabled
-          ? Math.Truncate(decimalHours) % 24
-          : Math.Truncate(decimalHours) % 12 == 0
-            ? 12
-            : Math.Truncate(decimalHours) % 12;
-      }
+      this_.SelectedHour = this_.Is24HModeEnabled
+        ? Math.Truncate(decimalHours) % 24
+        : Math.Truncate(decimalHours) % 12 == 0
+          ? 12
+          : Math.Truncate(decimalHours) % 12;
 
       var decimalMinutes = minuteValue % 60;
       var minutes = Math.Truncate(decimalMinutes);
 
       var decimalPart = decimalMinutes - Math.Truncate(decimalMinutes);
-      double decimalSeconds = Math.Round(decimalPart * 60, MidpointRounding.AwayFromZero);
-      isOverflow = decimalSeconds >= 1.0;
-      if (isOverflow)
-      {
-        this_.SelectedSecond = decimalSeconds;
-      }
+      double decimalSeconds = Math.Truncate(decimalPart * 60);
+      this_.SelectedSecond = decimalSeconds;
 
       this_.IsUpdatingSelectedTimeComponent = false;
       return minutes;
@@ -342,26 +326,18 @@ private static object CoerceSeconds(DependencyObject d, object basevalue)
       this_.IsUpdatingSelectedTimeComponent = true;
       var secondsValue = (double) basevalue;
       double decimalHours = secondsValue / 3600;
-      bool isOverflow = decimalHours >= 1.0;
-      if (isOverflow)
-      {
-        this_.SelectedHour = this_.Is24HModeEnabled
-          ? Math.Truncate(decimalHours) % 24
-          : Math.Truncate(decimalHours) % 12 == 0
-            ? 12
-            : Math.Truncate(decimalHours) % 12;
-      }
+      this_.SelectedHour = this_.Is24HModeEnabled
+        ? Math.Truncate(decimalHours) % 24
+        : Math.Truncate(decimalHours) % 12 == 0
+          ? 12
+          : Math.Truncate(decimalHours) % 12;
 
       var minutePart = secondsValue % 3600;
       double decimalMinutes = minutePart / 60;
-      isOverflow = decimalMinutes >= 1.0;
-      if (isOverflow)
-      {
-        this_.SelectedMinute = Math.Truncate(decimalMinutes);
-      }
+      this_.SelectedMinute = Math.Truncate(decimalMinutes);
 
       double decimalSeconds = minutePart % 60;
-      var seconds = Math.Round(decimalSeconds, MidpointRounding.AwayFromZero);
+      var seconds = Math.Truncate(decimalSeconds);
 
       this_.IsUpdatingSelectedTimeComponent = false;
       return seconds;

BionicCode.Net/BionicCode.Controls.Net.Wpf/ClockFace.cs renamed to BionicCode.Net/BionicCode.Controls.Net.Wpf/Clock/ClockFace.cs

@@ -31,8 +31,8 @@ protected override void OnSelectedTimeChanged(DateTime oldValue, DateTime newVal
     {
       base.OnSelectedTimeChanged(oldValue, newValue);
 
-      double concatenatedTimeValues = this.SelectedHour * 10000 
-                                      + this.SelectedMinute * 100 
+      double concatenatedTimeValues = this.SelectedHour * Math.Pow(10, 4) 
+                                      + this.SelectedMinute * Math.Pow(10, 2) 
                                       + this.SelectedSecond;
       this.SegmentDisplayDriver.SetValue((int) concatenatedTimeValues);
     }