Merge pull request #6 from lastowl/feature/file-based-schedules

File-based schedule picker, side-by-side layout, display mode fixes

Author: lastowl

OnlyT.Avalonia/Converters/PercentToGridLengthConverter.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Globalization;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Data.Converters;
+
+namespace OnlyT.Avalonia.Converters;
+
+public class PercentToGridLengthConverter : IValueConverter
+{
+    public static readonly PercentToGridLengthConverter Instance = new();
+    public static readonly PercentToGridLengthConverter ComplementInstance = new() { IsComplement = true };
+
+    public bool IsComplement { get; set; }
+
+    public object? Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        if (value is int percent)
+        {
+            var v = IsComplement ? (100 - percent) : percent;
+            return new GridLength(Math.Max(v, 1), GridUnitType.Star);
+        }
+
+        return new GridLength(1, GridUnitType.Star);
+    }
+
+    public object? ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        throw new NotImplementedException();
+    }
+}

OnlyT.Avalonia/Properties/Resources.resx

@@ -825,6 +825,30 @@ Shift - Increase 5m</value>
     <value>Min</value>
     <comment>Watermark/placeholder for the quick-set minutes input in manual mode</comment>
   </data>
+  <data name="BTN_SAVE_TEMPLATE" xml:space="preserve">
+    <value>Save</value>
+    <comment>Button to export current schedule as a reusable template file</comment>
+  </data>
+  <data name="TIP_EXPORT_SCHEDULE" xml:space="preserve">
+    <value>Save current schedule as a reusable template</value>
+    <comment>Tooltip for the save-template button in file-based mode</comment>
+  </data>
+  <data name="SCHEDULE_FILE" xml:space="preserve">
+    <value>Schedule file</value>
+    <comment>Label for the schedule template file selector in settings</comment>
+  </data>
+  <data name="SHOW_EXPORT_SCHEDULE" xml:space="preserve">
+    <value>Show export schedule button</value>
+    <comment>Checkbox in Settings > Misc to show/hide the schedule export icon on operator page</comment>
+  </data>
+  <data name="SPLIT_WIDTH_TIP" xml:space="preserve">
+    <value>Controls the analogue clock size. Only applies in horizontal layout with an analogue clock.</value>
+    <comment>Tooltip for the analogue clock width slider</comment>
+  </data>
+  <data name="HORIZONTAL_CLOCK_LAYOUT" xml:space="preserve">
+    <value>Side-by-side clock layout (clock left, timer right)</value>
+    <comment>Checkbox in Timer Window section to switch between horizontal and vertical clock layouts</comment>
+  </data>
   <data name="MENU_PLUS_15_SEC" xml:space="preserve">
     <value>+15 seconds</value>
     <comment>Context menu item for time adjustment</comment>

OnlyT.Avalonia/Services/IOptionsService.cs

@@ -392,6 +392,17 @@ public class AppOptions
     /// </summary>
     public bool ClassicMode { get; set; } = false;
 
+    /// <summary>
+    /// Filename (not full path) of the selected schedule template within
+    /// the Schedules folder. When empty, the legacy talk_schedule.xml is
+    /// used for backward compatibility.
+    /// </summary>
+    public string SelectedScheduleFile { get; set; } = string.Empty;
+
+    public bool ShowExportScheduleButton { get; set; } = false;
+
+    public bool HorizontalClockLayout { get; set; } = false;
+
     /// <summary>
     /// Adaptive timer mode for midweek meetings (default: None)
     /// </summary>

OnlyT.Avalonia/Services/SimpleOptionsService.cs

@@ -212,13 +212,23 @@ public void SaveOptions(AppOptions options)
 
             Log.Debug("Options saved successfully");
 
-            try
-            {
-                OptionsChanged?.Invoke(this, EventArgs.Empty);
-            }
-            catch (Exception ex)
+            // Invoke each subscriber individually so one failing handler
+            // doesn't prevent subsequent handlers from running. Previously
+            // a single Invoke + catch swallowed the first exception and
+            // silently skipped all remaining subscribers.
+            if (OptionsChanged != null)
             {
-                Log.Warning(ex, "OptionsChanged subscriber threw");
+                foreach (var handler in OptionsChanged.GetInvocationList())
+                {
+                    try
+                    {
+                        ((EventHandler)handler)(this, EventArgs.Empty);
+                    }
+                    catch (Exception ex)
+                    {
+                        Log.Warning(ex, "OptionsChanged subscriber threw");
+                    }
+                }
             }
         }
         catch (UnauthorizedAccessException ex)

OnlyT.Avalonia/Services/TalkSchedule/TalkScheduleFileBased.cs

@@ -16,13 +16,13 @@ internal static class TalkScheduleFileBased
 {
     private static readonly int StartId = 5000;
 
-    public static List<TalkScheduleItem> Read(bool autoBell)
+    public static List<TalkScheduleItem> Read(bool autoBell, string? selectedFile = null)
     {
         var result = new List<TalkScheduleItem>();
+        var path = ResolvePath(selectedFile);
 
-        if (Exists())
+        if (File.Exists(path))
         {
-            var path = GetFullPath();
             try
             {
                 var x = XDocument.Load(path);
@@ -62,22 +62,32 @@ public static List<TalkScheduleItem> Read(bool autoBell)
         }
         else
         {
-            Log.Information("Talk schedule file not found: {Path}", GetFullPath());
+            Log.Information("Talk schedule file not found: {Path}", path);
         }
 
         return result;
     }
 
-    private static string GetFullPath()
+    /// <summary>
+    /// Resolves the schedule file path. If a selected template filename is
+    /// provided, it is looked up in the Schedules folder. Otherwise falls
+    /// back to the legacy talk_schedule.xml for backward compatibility.
+    /// </summary>
+    private static string ResolvePath(string? selectedFile)
     {
+        if (!string.IsNullOrEmpty(selectedFile))
+        {
+            var templatePath = System.IO.Path.Combine(
+                FileUtils.GetScheduleTemplatesFolder(), selectedFile);
+            if (File.Exists(templatePath))
+            {
+                return templatePath;
+            }
+            Log.Warning("Selected schedule template not found: {File}, falling back to default", selectedFile);
+        }
         return FileUtils.GetTalkSchedulePath();
     }
 
-    private static bool Exists()
-    {
-        return File.Exists(GetFullPath());
-    }
-
     private static bool? AttributeToNullableBool(XAttribute? attribute, bool? defaultValue)
     {
         return string.IsNullOrEmpty(attribute?.Value)

OnlyT.Avalonia/Services/TalkSchedule/TalkScheduleService.cs

@@ -25,8 +25,9 @@ public TalkScheduleService(IOptionsService optionsService)
 
     public void Reset()
     {
+        var selectedFile = _optionsService.GetOptions().SelectedScheduleFile;
         _fileBasedSchedule = new Lazy<IEnumerable<TalkScheduleItem>>(() =>
-            TalkScheduleFileBased.Read(_optionsService.AutoBell));
+            TalkScheduleFileBased.Read(_optionsService.AutoBell, selectedFile));
         _autoSchedule = new Lazy<IEnumerable<TalkScheduleItem>>(() =>
             TalkScheduleAuto.Read(_optionsService));
         _manualSchedule = new Lazy<IEnumerable<TalkScheduleItem>>(() =>

OnlyT.Avalonia/Utils/FileUtils.cs

@@ -91,6 +91,13 @@ public static string GetTalkSchedulePath()
         return Path.Combine(GetDocumentsFolder(), "talk_schedule.xml");
     }
 
+    public static string GetScheduleTemplatesFolder()
+    {
+        var folder = Path.Combine(GetDocumentsFolder(), "Schedules");
+        Directory.CreateDirectory(folder);
+        return folder;
+    }
+
     public static string GetTimingReportsFolder(string? identifier = null)
     {
         var folder = Path.Combine(GetDocumentsFolder(), "TimingReports", identifier ?? string.Empty);

OnlyT.Avalonia/Utils/ScheduleExporter.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Xml.Linq;
+using OnlyT.Avalonia.Models;
+using Serilog;
+
+namespace OnlyT.Avalonia.Utils;
+
+/// <summary>
+/// Serializes a talk schedule to the file-based XML format so that the
+/// current Automatic/Manual schedule can be saved as a reusable template.
+/// </summary>
+public static class ScheduleExporter
+{
+    public static void Export(IEnumerable<TalkScheduleItem> talks, string filePath)
+    {
+        var items = new XElement("items");
+
+        foreach (var talk in talks)
+        {
+            var item = new XElement("item",
+                new XAttribute("name", talk.Name ?? string.Empty),
+                new XAttribute("duration", talk.OriginalDuration.ToString(@"hh\:mm\:ss")),
+                new XAttribute("editable", talk.Editable.ToString().ToLower()),
+                new XAttribute("bell", talk.BellApplicable.ToString().ToLower()));
+
+            if (!string.IsNullOrEmpty(talk.MeetingSectionNameInternal))
+            {
+                item.Add(new XAttribute("section", talk.MeetingSectionNameInternal));
+            }
+
+            if (talk.CountUp.HasValue)
+            {
+                item.Add(new XAttribute("countup", talk.CountUp.Value.ToString().ToLower()));
+            }
+
+            if (talk.PersistFinalTimerValue)
+            {
+                item.Add(new XAttribute("persist", "true"));
+            }
+
+            if (talk.ClosingSecs != 30)
+            {
+                item.Add(new XAttribute("closing", talk.ClosingSecs));
+            }
+
+            items.Add(item);
+        }
+
+        var doc = new XDocument(new XElement("meeting", items));
+        doc.Save(filePath);
+
+        Log.Information("Exported schedule template to {Path} ({Count} talks)",
+            filePath, items.Elements().Count());
+    }
+
+    public static string[] GetAvailableTemplates()
+    {
+        var folder = FileUtils.GetScheduleTemplatesFolder();
+        if (!Directory.Exists(folder))
+        {
+            return [];
+        }
+
+        return Directory.GetFiles(folder, "*.xml");
+    }
+}

OnlyT.Avalonia/ViewModels/OperatorPageViewModel.cs

@@ -148,6 +148,7 @@ private void OnOptionsChangedExternally()
             OnPropertyChanged(nameof(ShouldShowCircuitVisitToggle));
             OnPropertyChanged(nameof(AllowCountUpDownToggle));
             OnPropertyChanged(nameof(ShowUpDownButton));
+            OnPropertyChanged(nameof(ShowExportScheduleButton));
 
             // If OperatingMode or MidWeekOrWeekend changed, the entire talk
             // schedule needs rebuilding (different mode = different talk list).
@@ -164,6 +165,13 @@ private void OnOptionsChangedExternally()
                 RefreshTalks();
             }
 
+            // Directly refresh the timer output VM so display-mode, clock
+            // format, and all visual settings update on the output window.
+            // This bypasses the OptionsChanged event subscription (which
+            // was unreliable) and ensures the refresh runs on the UI thread.
+            var timerOutputViewModel = CommunityToolkit.Mvvm.DependencyInjection.Ioc.Default.GetService<TimerOutputViewModel>();
+            timerOutputViewModel?.RefreshSettings();
+
             // Apply AlwaysOnTop + FullScreenMode + MonitorId to the output window
             ApplyWindowStateOptionsLive();
         });
@@ -323,6 +331,8 @@ public string BellTooltip
     public bool IsManualMode => _optionsService.OperatingMode == OperatingMode.Manual;
     public bool IsNotManualMode => !IsManualMode;
     public bool IsAutoMode => _optionsService.OperatingMode == OperatingMode.Automatic;
+    public bool IsFileBasedMode => _optionsService.OperatingMode == OperatingMode.ScheduleFile;
+    public bool ShowExportScheduleButton => _optionsService.GetOptions().ShowExportScheduleButton;
 
     // Circuit visit
     public bool IsCircuitVisit
@@ -579,6 +589,13 @@ public void RefreshTalks()
         OnPropertyChanged(nameof(IsManualMode));
         OnPropertyChanged(nameof(IsNotManualMode));
         OnPropertyChanged(nameof(IsAutoMode));
+        OnPropertyChanged(nameof(IsFileBasedMode));
+
+        // Refresh the schedule-file picker (may have new templates)
+        if (IsFileBasedMode)
+        {
+            RefreshScheduleFiles();
+        }
 
         // Refresh timer output settings (e.g., analog/digital clock switch)
         var timerOutputViewModel = CommunityToolkit.Mvvm.DependencyInjection.Ioc.Default.GetService<TimerOutputViewModel>();
@@ -1222,6 +1239,89 @@ private void SkipTalk()
 
     private bool CanSkipTalk() => !IsRunning && !IsPaused && SelectedTalk != null;
 
+    // --- File-based schedule picker + export ---
+
+    [ObservableProperty]
+    private ObservableCollection<string> _scheduleFiles = [];
+
+    [ObservableProperty]
+    private string? _selectedScheduleFile;
+
+    partial void OnSelectedScheduleFileChanged(string? value)
+    {
+        if (value == null) return;
+        var options = _optionsService.GetOptions();
+        options.SelectedScheduleFile = value;
+        _optionsService.SaveOptions(options);
+        RefreshTalks();
+    }
+
+    public void RefreshScheduleFiles()
+    {
+        var files = Utils.ScheduleExporter.GetAvailableTemplates();
+
+        // First-use seeding: if there are no templates yet and we have
+        // talks loaded (from a previous Auto/Manual session), export
+        // the current schedule as a starting template so the user has
+        // something to work with immediately.
+        if (files.Length == 0 && Talks.Count > 0)
+        {
+            var seedPath = System.IO.Path.Combine(
+                Utils.FileUtils.GetScheduleTemplatesFolder(), "default.xml");
+            Utils.ScheduleExporter.Export(Talks, seedPath);
+            files = Utils.ScheduleExporter.GetAvailableTemplates();
+        }
+
+        ScheduleFiles.Clear();
+        foreach (var f in files)
+        {
+            ScheduleFiles.Add(System.IO.Path.GetFileName(f));
+        }
+
+        var current = _optionsService.GetOptions().SelectedScheduleFile;
+        if (!string.IsNullOrEmpty(current) && ScheduleFiles.Contains(current))
+        {
+            SelectedScheduleFile = current;
+        }
+        else if (ScheduleFiles.Count > 0)
+        {
+            SelectedScheduleFile = ScheduleFiles[0];
+        }
+
+        OnPropertyChanged(nameof(IsFileBasedMode));
+    }
+
+    [RelayCommand]
+    private void ExportScheduleAsTemplate()
+    {
+        var folder = Utils.FileUtils.GetScheduleTemplatesFolder();
+        var talks = Talks;
+
+        if (talks.Count == 0)
+        {
+            StatusText = "No talks to export";
+            return;
+        }
+
+        // Generate a unique filename based on the current mode/meeting type
+        var prefix = _optionsService.OperatingMode switch
+        {
+            OperatingMode.Automatic => _optionsService.MidWeekOrWeekend == MidWeekOrWeekend.MidWeek ? "midweek" : "weekend",
+            OperatingMode.Manual => "manual",
+            OperatingMode.ScheduleFile => "custom",
+            _ => "schedule"
+        };
+
+        var timestamp = System.DateTime.Now.ToString("yyyyMMdd-HHmmss");
+        var filename = $"{prefix}-{timestamp}.xml";
+        var path = System.IO.Path.Combine(folder, filename);
+
+        Utils.ScheduleExporter.Export(talks, path);
+        StatusText = $"Saved: {filename}";
+
+        RefreshScheduleFiles();
+    }
+
     // Quick-set: user types minutes in manual mode and presses Enter.
     [ObservableProperty]
     private decimal _quickSetMinutes = 5;