FModel v4.0

FModel/Framework/AsyncQueue.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks.Dataflow;
+
+namespace FModel.Framework
+{
+    public class AsyncQueue<T> : IAsyncEnumerable<T>
+    {
+        private readonly SemaphoreSlim _semaphore = new(1);
+        private readonly BufferBlock<T> _buffer = new();
+
+        public int Count => _buffer.Count;
+
+        public void Enqueue(T item) => _buffer.Post(item);
+
+        public async IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken token = default)
+        {
+            await _semaphore.WaitAsync(token);
+            try
+            {
+                while (Count > 0)
+                {
+                    token.ThrowIfCancellationRequested();
+                    yield return await _buffer.ReceiveAsync(token);
+                }
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+    }
+}

FModel/Framework/Command.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Windows.Input;
+
+namespace FModel.Framework
+{
+    public abstract class Command : ICommand
+    {
+        public abstract void Execute(object parameter);
+
+        public abstract bool CanExecute(object parameter);
+
+        public void RaiseCanExecuteChanged()
+        {
+            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+        }
+
+        public event EventHandler CanExecuteChanged;
+    }
+}

FModel/Framework/CustomSKShaper.cs

@@ -0,0 +1,96 @@
+using System;
+using HarfBuzzSharp;
+using SkiaSharp;
+using SkiaSharp.HarfBuzz;
+using Buffer = HarfBuzzSharp.Buffer;
+
+namespace FModel.Framework
+{
+    public class CustomSKShaper : SKShaper
+    {
+        private const int _FONT_SIZE_SCALE = 512;
+        private readonly Font _font;
+        private readonly Buffer _buffer;
+
+        public CustomSKShaper(SKTypeface typeface) : base(typeface)
+        {
+            using (var blob = Typeface.OpenStream(out var index).ToHarfBuzzBlob())
+            using (var face = new Face(blob, index))
+            {
+                face.Index = index;
+                face.UnitsPerEm = Typeface.UnitsPerEm;
+
+                _font = new Font(face);
+                _font.SetScale(_FONT_SIZE_SCALE, _FONT_SIZE_SCALE);
+                _font.SetFunctionsOpenType();
+            }
+
+            _buffer = new Buffer();
+        }
+
+        public new Result Shape(Buffer buffer, float xOffset, float yOffset, SKPaint paint)
+        {
+            if (buffer == null)
+                throw new ArgumentNullException(nameof(buffer));
+
+            if (paint == null)
+                throw new ArgumentNullException(nameof(paint));
+
+            // do the shaping
+            _font.Shape(buffer);
+
+            // get the shaping results
+            var len = buffer.Length;
+            var info = buffer.GlyphInfos;
+            var pos = buffer.GlyphPositions;
+
+            // get the sizes
+            var textSizeY = paint.TextSize / _FONT_SIZE_SCALE;
+            var textSizeX = textSizeY * paint.TextScaleX;
+
+            var points = new SKPoint[len];
+            var clusters = new uint[len];
+            var codepoints = new uint[len];
+
+            for (var i = 0; i < len; i++)
+            {
+                // move the cursor
+                xOffset += pos[i].XAdvance * textSizeX;
+                yOffset += pos[i].YAdvance * textSizeY;
+
+                codepoints[i] = info[i].Codepoint;
+                clusters[i] = info[i].Cluster;
+                points[i] = new SKPoint(xOffset + pos[i].XOffset * textSizeX, yOffset - pos[i].YOffset * textSizeY);
+            }
+
+            return new Result(codepoints, clusters, points);
+        }
+
+        public new Result Shape(string text, SKPaint paint) => Shape(text, 0, 0, paint);
+
+        public new Result Shape(string text, float xOffset, float yOffset, SKPaint paint)
+        {
+            if (string.IsNullOrEmpty(text))
+                return new Result();
+
+            using var buffer = new Buffer();
+            switch (paint.TextEncoding)
+            {
+                case SKTextEncoding.Utf8:
+                    buffer.AddUtf8(text);
+                    break;
+                case SKTextEncoding.Utf16:
+                    buffer.AddUtf16(text);
+                    break;
+                case SKTextEncoding.Utf32:
+                    buffer.AddUtf32(text);
+                    break;
+                default:
+                    throw new NotSupportedException("TextEncoding of type GlyphId is not supported.");
+            }
+
+            buffer.GuessSegmentProperties();
+            return Shape(buffer, xOffset, yOffset, paint);
+        }
+    }
+}

FModel/Framework/FullyObservableCollection.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+
+namespace FModel.Framework
+{
+    public class FullyObservableCollection<T> : ObservableCollection<T> where T : INotifyPropertyChanged
+    {
+        /// <summary>
+        /// Occurs when a property is changed within an item.
+        /// </summary>
+        public event EventHandler<ItemPropertyChangedEventArgs> ItemPropertyChanged;
+
+        public FullyObservableCollection()
+        {
+        }
+
+        public FullyObservableCollection(List<T> list) : base(list)
+        {
+            ObserveAll();
+        }
+
+        public FullyObservableCollection(IEnumerable<T> enumerable) : base(enumerable)
+        {
+            ObserveAll();
+        }
+
+        protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
+        {
+            if (e.Action is NotifyCollectionChangedAction.Remove or
+                NotifyCollectionChangedAction.Replace)
+            {
+                foreach (T item in e.OldItems)
+                    item.PropertyChanged -= ChildPropertyChanged;
+            }
+
+            if (e.Action is NotifyCollectionChangedAction.Add or
+                NotifyCollectionChangedAction.Replace)
+            {
+                foreach (T item in e.NewItems)
+                    item.PropertyChanged += ChildPropertyChanged;
+            }
+
+            base.OnCollectionChanged(e);
+        }
+
+        protected void OnItemPropertyChanged(ItemPropertyChangedEventArgs e)
+        {
+            ItemPropertyChanged?.Invoke(this, e);
+        }
+
+        protected void OnItemPropertyChanged(int index, PropertyChangedEventArgs e)
+        {
+            OnItemPropertyChanged(new ItemPropertyChangedEventArgs(index, e));
+        }
+
+        protected override void ClearItems()
+        {
+            foreach (T item in Items)
+                item.PropertyChanged -= ChildPropertyChanged;
+
+            base.ClearItems();
+        }
+
+        private void ObserveAll()
+        {
+            foreach (T item in Items)
+                item.PropertyChanged += ChildPropertyChanged;
+        }
+
+        private void ChildPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            var typedSender = (T) sender;
+            var i = Items.IndexOf(typedSender);
+
+            if (i < 0)
+                throw new ArgumentException("Received property notification from item not in collection");
+
+            OnItemPropertyChanged(i, e);
+        }
+    }
+
+    /// <summary>
+    /// Provides data for the <see cref="FullyObservableCollection{T}.ItemPropertyChanged"/> event.
+    /// </summary>
+    public class ItemPropertyChangedEventArgs : PropertyChangedEventArgs
+    {
+        /// <summary>
+        /// Gets the index in the collection for which the property change has occurred.
+        /// </summary>
+        /// <value>
+        /// Index in parent collection.
+        /// </value>
+        public int CollectionIndex { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ItemPropertyChangedEventArgs"/> class.
+        /// </summary>
+        /// <param name="index">The index in the collection of changed item.</param>
+        /// <param name="name">The name of the property that changed.</param>
+        public ItemPropertyChangedEventArgs(int index, string name) : base(name)
+        {
+            CollectionIndex = index;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ItemPropertyChangedEventArgs"/> class.
+        /// </summary>
+        /// <param name="index">The index.</param>
+        /// <param name="args">The <see cref="PropertyChangedEventArgs"/> instance containing the event data.</param>
+        public ItemPropertyChangedEventArgs(int index, PropertyChangedEventArgs args) : this(index, args.PropertyName)
+        {
+        }
+    }
+}

FModel/Framework/Hotkey.cs

@@ -0,0 +1,50 @@
+using System.Text;
+using System.Windows.Input;
+
+namespace FModel.Framework
+{
+    public class Hotkey : ViewModel
+    {
+        private Key _key;
+        public Key Key
+        {
+            get => _key;
+            set => SetProperty(ref _key, value);
+        }
+
+        private ModifierKeys _modifiers;
+        public ModifierKeys Modifiers
+        {
+            get => _modifiers;
+            set => SetProperty(ref _modifiers, value);
+        }
+
+        public Hotkey(Key key, ModifierKeys modifiers = ModifierKeys.None)
+        {
+            Key = key;
+            Modifiers = modifiers;
+        }
+
+        public bool IsTriggered(Key e)
+        {
+            return e == Key && Keyboard.Modifiers.HasFlag(Modifiers);
+        }
+
+        public override string ToString()
+        {
+            var str = new StringBuilder();
+
+            if (Modifiers.HasFlag(ModifierKeys.Control))
+                str.Append("Ctrl + ");
+            if (Modifiers.HasFlag(ModifierKeys.Shift))
+                str.Append("Shift + ");
+            if (Modifiers.HasFlag(ModifierKeys.Alt))
+                str.Append("Alt + ");
+            if (Modifiers.HasFlag(ModifierKeys.Windows))
+                str.Append("Win + ");
+
+            str.Append(Key);
+            return str.ToString();
+        }
+    }
+}

FModel/Framework/JsonNetSerializer.cs

@@ -0,0 +1,43 @@
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using RestSharp;
+using RestSharp.Serialization;
+
+namespace FModel.Framework
+{
+    public class JsonNetSerializer : IRestSerializer
+    {
+        public static readonly JsonSerializerSettings SerializerSettings = new()
+        {
+            NullValueHandling = NullValueHandling.Ignore,
+            MissingMemberHandling = MissingMemberHandling.Ignore,
+            ContractResolver = new CamelCasePropertyNamesContractResolver()
+        };
+
+        public string Serialize(object obj)
+        {
+            return JsonConvert.SerializeObject(obj);
+        }
+
+        [Obsolete]
+        public string Serialize(Parameter parameter)
+        {
+            return JsonConvert.SerializeObject(parameter.Value);
+        }
+
+        public T Deserialize<T>(IRestResponse response)
+        {
+            return JsonConvert.DeserializeObject<T>(response.Content, SerializerSettings);
+        }
+
+        public string[] SupportedContentTypes { get; } =
+        {
+            "application/json", "application/json; charset=UTF-8"
+        };
+
+        public string ContentType { get; set; } = "application/json; charset=UTF-8";
+
+        public DataFormat DataFormat => DataFormat.Json;
+    }
+}

FModel/Framework/RangeObservableCollection.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+
+namespace FModel.Framework
+{
+    public sealed class RangeObservableCollection<T> : ObservableCollection<T>
+    {
+        private bool _suppressNotification;
+
+        protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
+        {
+            if (!_suppressNotification)
+                base.OnCollectionChanged(e);
+        }
+
+        public void AddRange(IEnumerable<T> list)
+        {
+            if (list == null)
+                throw new ArgumentNullException(nameof(list));
+
+            _suppressNotification = true;
+
+            foreach (var item in list)
+                Add(item);
+
+            _suppressNotification = false;
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+        }
+
+        public void SetSuppressionState(bool state)
+        {
+            _suppressNotification = state;
+        }
+
+        public void InvokeOnCollectionChanged(NotifyCollectionChangedAction changedAction = NotifyCollectionChangedAction.Reset)
+        {
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(changedAction));
+        }
+    }
+}

FModel/Framework/ViewModel.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Newtonsoft.Json;
+
+namespace FModel.Framework
+{
+    public class ViewModel : INotifyPropertyChanged, INotifyDataErrorInfo, IDataErrorInfo
+    {
+        private readonly Dictionary<string, IList<string>> _validationErrors = new();
+
+        public string this[string propertyName]
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(propertyName))
+                    return Error;
+
+                return _validationErrors.ContainsKey(propertyName) ? string.Join(Environment.NewLine, _validationErrors[propertyName]) : string.Empty;
+            }
+        }
+
+        [JsonIgnore] public string Error => string.Join(Environment.NewLine, GetAllErrors());
+        [JsonIgnore] public bool HasErrors => _validationErrors.Any();
+
+        public IEnumerable GetErrors(string propertyName)
+        {
+            if (string.IsNullOrEmpty(propertyName))
+                return _validationErrors.SelectMany(kvp => kvp.Value);
+
+            return _validationErrors.TryGetValue(propertyName, out var errors) ? errors : Enumerable.Empty<object>();
+        }
+
+        private IEnumerable<string> GetAllErrors()
+        {
+            return _validationErrors.SelectMany(kvp => kvp.Value).Where(e => !string.IsNullOrEmpty(e));
+        }
+
+        public void AddValidationError(string propertyName, string errorMessage)
+        {
+            if (!_validationErrors.ContainsKey(propertyName))
+                _validationErrors.Add(propertyName, new List<string>());
+
+            _validationErrors[propertyName].Add(errorMessage);
+        }
+
+        public void ClearValidationErrors(string propertyName)
+        {
+            if (_validationErrors.ContainsKey(propertyName))
+                _validationErrors.Remove(propertyName);
+        }
+
+        public event PropertyChangedEventHandler PropertyChanged;
+#pragma warning disable 67
+        public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
+#pragma warning disable 67
+
+        protected void RaisePropertyChanged(string propertyName)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        protected virtual bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
+        {
+            if (EqualityComparer<T>.Default.Equals(storage, value))
+                return false;
+
+            storage = value;
+            RaisePropertyChanged(propertyName);
+            return true;
+        }
+    }
+}

FModel/Framework/ViewModelCommand.cs

@@ -0,0 +1,50 @@
+using System;
+
+namespace FModel.Framework
+{
+    public abstract class ViewModelCommand<TContextViewModel> : Command where TContextViewModel : ViewModel
+    {
+        private WeakReference _parent;
+
+        public TContextViewModel ContextViewModel
+        {
+            get
+            {
+                if (_parent is {IsAlive: true})
+                    return (TContextViewModel) _parent.Target;
+
+                return null;
+            }
+
+            private set
+            {
+                if (ContextViewModel == value)
+                    return;
+
+                _parent = value != null ? new WeakReference(value) : null;
+            }
+        }
+
+        protected ViewModelCommand(TContextViewModel contextViewModel)
+        {
+            ContextViewModel = contextViewModel /*?? throw new ArgumentNullException(nameof(contextViewModel))*/;
+        }
+
+        public sealed override void Execute(object parameter)
+        {
+            Execute(ContextViewModel, parameter);
+        }
+
+        public abstract void Execute(TContextViewModel contextViewModel, object parameter);
+
+        public sealed override bool CanExecute(object parameter)
+        {
+            return CanExecute(ContextViewModel, parameter);
+        }
+
+        public virtual bool CanExecute(TContextViewModel contextViewModel, object parameter)
+        {
+            return true;
+        }
+    }
+}