FormattedTextBox.cs

//
// Copyright Fela Ameghino 2015-2025
//
// Distributed under the GNU General Public License v3.0. (See accompanying
// file LICENSE or copy at https://www.gnu.org/licenses/gpl-3.0.txt)
//
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Text;
using Telegram.Common;
using Telegram.Controls.Media;
using Telegram.Controls.Messages;
using Telegram.Navigation;
using Telegram.Services;
using Telegram.Td;
using Telegram.Td.Api;
using Telegram.Views.Popups;
using Windows.ApplicationModel.DataTransfer;
using Windows.Foundation;
using Windows.System;
using Windows.UI;
using Windows.UI.Core;
using Windows.UI.Text;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Hosting;
using Windows.UI.Xaml.Input;

namespace Telegram.Controls
{
    [Flags]
    public enum FormattedTextEntity
    {
        None = 0,
        Bold = 1,
        Italic = 2,
        Underline = 4,
        Strikethrough = 8,
        Mono = 16,
        Spoiler = 32,
        Quote = 64,
        TextUrl = 128,
        CustomEmoji = 256,
        All = Bold | Italic | Underline | Strikethrough | Mono | Spoiler | Quote | TextUrl | CustomEmoji
    }

    public partial class FormattedTextBox : RichEditBox
    {
        private readonly FormattedTextFlyout _selectionFlyout;
        private readonly MenuFlyoutSubItem _proofingFlyout;

        private bool _updateLocked;
        private bool _fromTextChanging;
        private bool _isContentChanging;
        private bool _undoGroup;

        private int _selectionIndex;

        public CustomEmojiCanvas CustomEmoji { get; set; }
        private Grid Blocks;
        private ScrollViewer ContentElement;

        protected int _blockPadding = 24;

        public FormattedTextBox()
        {
            DefaultStyleKey = typeof(FormattedTextBox);

            ClipboardCopyFormat = RichEditClipboardFormat.PlainText;

            CopyingToClipboard += OnCopyingToClipboard;
            CuttingToClipboard += OnCuttingToClipboard;

            Paste += OnPaste;
            PreviewKeyDown += OnPreviewKeyDown;

            _proofingFlyout = new MenuFlyoutSubItem
            {
                Text = Strings.Spelling
            };

            SelectionFlyout = new Flyout
            {
                Content = _selectionFlyout = new FormattedTextFlyout(this),

                AllowFocusOnInteraction = false,
                ShouldConstrainToRootBounds = false,
                ShowMode = FlyoutShowMode.TransientWithDismissOnPointerMoveAway,
                FlyoutPresenterStyle = BootStrapper.Current.Resources["CommandFlyoutPresenterStyle"] as Style,
            };

            ContextFlyout = new MenuFlyout();
            ContextFlyout.Opening += OnContextFlyoutOpening;
            ContextFlyout.Closing += OnContextFlyoutClosing;

            DisabledFormattingAccelerators = DisabledFormattingAccelerators.All;
            KeyboardAcceleratorPlacementMode = KeyboardAcceleratorPlacementMode.Hidden;

            CreateKeyboardAccelerator(VirtualKey.B);
            CreateKeyboardAccelerator(VirtualKey.I);
            CreateKeyboardAccelerator(VirtualKey.U);
            CreateKeyboardAccelerator(VirtualKey.X, VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift);
            CreateKeyboardAccelerator(VirtualKey.M, VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift);
            CreateKeyboardAccelerator(VirtualKey.P, VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift);
            CreateKeyboardAccelerator(VirtualKey.K);
            CreateKeyboardAccelerator(VirtualKey.N, VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift);

            // Used for special characters
            CreateKeyboardAccelerator(VirtualKey.X, VirtualKeyModifiers.Menu);

            Loaded += OnLoaded;
            Unloaded += OnUnloaded;
            SizeChanged += OnSizeChanged;

            TextChanging += OnTextChanging;
            TextChanged += OnTextChanged;

            SelectionChanged += OnSelectionChanged;
        }

        private void OnCopyingToClipboard(RichEditBox sender, TextControlCopyingToClipboardEventArgs args)
        {
            args.Handled = true;

            if (Document.Selection.Length != 0)
            {
                MessageHelper.CopyText(null, GetFormattedText(Document.Selection, false, false));
            }
        }

        private void OnCuttingToClipboard(RichEditBox sender, TextControlCuttingToClipboardEventArgs args)
        {
            args.Handled = true;

            if (Document.Selection.Length != 0)
            {
                MessageHelper.CopyText(null, GetFormattedText(Document.Selection, true, false));
            }
        }

        private void OnTextChanging(RichEditBox sender, RichEditBoxTextChangingEventArgs args)
        {
            _isContentChanging = args.IsContentChanging;
            _fromTextChanging = true;
            _isEmpty = null;

            if (args.IsContentChanging)
            {
                // Fixes insertion of some fully qualified emoji from WIN+.
                var inserted = Document.GetRange(Document.Selection.StartPosition - 1, Document.Selection.StartPosition);
                if (inserted.Text.EndsWith('\uFE0F'))
                {
                    inserted.Text = inserted.Text;
                }

                UpdateFormat();
            }
        }

        private void OnTextChanged(object sender, RoutedEventArgs e)
        {
            UpdateCustomEmoji();
            UpdateBlocks();

            if (_updateLocked || !_isContentChanging)
            {
                return;
            }

            TextChangedForRealNoCap?.Invoke(this, EventArgs.Empty);
        }

        private void OnSelectionChanged(object sender, RoutedEventArgs e)
        {
            var index = Document.Selection.EndPosition;

            if (Document.Selection.Length == 0)
            {
                Document.Selection.StartOf(TextRangeUnit.Hidden, true);
                Document.Selection.Collapse(true);
            }

            OnSelectionChanged(this, _fromTextChanging || _selectionIndex == index);

            _fromTextChanging = false;
            _selectionIndex = index;
        }

        protected virtual void OnSelectionChanged(RichEditBox sender, bool fromTextChanging)
        {

        }

        private void OnSizeChanged(object sender, SizeChangedEventArgs e)
        {
            if (double.IsNaN(Height))
            {
                return;
            }

            Height = double.NaN;
        }

        protected override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
            this.CreateInsetClip();

            CustomEmoji ??= GetTemplateChild(nameof(CustomEmoji)) as CustomEmojiCanvas;
            Blocks = GetTemplateChild(nameof(Blocks)) as Grid;
            ContentElement = GetTemplateChild(nameof(ContentElement)) as ScrollViewer;

            ContentElement.ViewChanged += ContentElement_ViewChanged;

            var props = ElementCompositionPreview.GetScrollViewerManipulationPropertySet(ContentElement);
            var translation = props.Compositor.CreateExpressionAnimation("scrollViewer.Translation.Y");
            translation.SetReferenceParameter("scrollViewer", props);

            if (Blocks != null)
            {
                ElementCompositionPreview.SetIsTranslationEnabled(Blocks, true);
                var visual = ElementComposition.GetElementVisual(Blocks);
                visual.StartAnimation("Translation.Y", translation);
            }

            if (CustomEmoji != null)
            {
                ElementCompositionPreview.SetIsTranslationEnabled(CustomEmoji, true);
                var visual = ElementComposition.GetElementVisual(CustomEmoji);
                visual.StartAnimation("Translation.Y", translation);
            }
        }

        private void OnLoaded(object sender, RoutedEventArgs e)
        {
            Window.Current.CoreWindow.CharacterReceived += OnCharacterReceived;
        }

        private void OnUnloaded(object sender, RoutedEventArgs e)
        {
            Window.Current.CoreWindow.CharacterReceived -= OnCharacterReceived;
        }

        public bool IsReplaceEmojiEnabled { get; set; } = true;

        private void OnCharacterReceived(CoreWindow sender, CharacterReceivedEventArgs args)
        {
            if (FocusState == FocusState.Unfocused || !IsReplaceEmojiEnabled || string.Equals(Document.Selection.CharacterFormat.Name, "Consolas", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            var character = Encoding.UTF32.GetString(BitConverter.GetBytes(args.KeyCode));

            //var matches = Emoticon.Data.Keys.Where(x => x.EndsWith(character)).ToArray();
            if (Emoticon.Matches.TryGetValue(character[0], out string[] matches))
            {
                var length = matches.Max(x => x.Length);
                var start = Math.Max(Document.Selection.EndPosition - length, 0);

                var range = Document.GetRange(start, Document.Selection.EndPosition);
                range.GetText(TextGetOptions.NoHidden, out string value);

                var emoticon = matches.FirstOrDefault(x => value.EndsWith(x));
                if (emoticon != null)
                {
                    BeginUndoGroup();
                    range.SetRange(range.EndPosition - emoticon.Length, range.EndPosition);
                    range.SetText(TextSetOptions.None, emoticon);
                    range.CharacterFormat.Hidden = FormatEffect.On;
                    range.SetRange(range.EndPosition, range.EndPosition);
                    range.SetText(TextSetOptions.None, Emoticon.Data[emoticon]);
                    EndUndoGroup();

                    Document.Selection.SetRange(range.EndPosition, range.EndPosition);
                    args.Handled = true;
                }
            }
        }

        protected override void OnKeyDown(KeyRoutedEventArgs e)
        {
            //if (_resetSize)
            //{
            //    _resetSize = false;
            //    Height = double.NaN;
            //}

            if (e.Key is VirtualKey.Back or VirtualKey.Delete && IsReplaceEmojiEnabled)
            {
                BeginUndoGroup();

                base.OnKeyDown(e);

                if (Document.Selection.Expand(TextRangeUnit.Hidden) != 0 && Emoticon.Data.ContainsKey(Document.Selection.Text))
                {
                    Document.Selection.CharacterFormat.Hidden = FormatEffect.Off;
                    Document.Selection.Collapse(e.Key is VirtualKey.Delete);
                }

                EndUndoGroup();
                return;
            }
            else if (e.Key == VirtualKey.Enter && CanAccept())
            {
                var modifiers = WindowContext.KeyModifiers();
                var send = SettingsService.Current.IsSendByEnterEnabled
                    ? modifiers == VirtualKeyModifiers.None
                    : modifiers == VirtualKeyModifiers.Control;

                AcceptsReturn = !send;
                e.Handled = send;

                // If handwriting panel is open, the app would crash on send.
                // Still, someone should fill a ticket to Microsoft about this.
                if (send && HandwritingView.IsOpen)
                {
                    void handler(object s, RoutedEventArgs args)
                    {
                        OnAccept();
                        HandwritingView.Unloaded -= handler;
                    }

                    HandwritingView.Unloaded += handler;
                    HandwritingView.TryClose();
                }
                else if (send)
                {
                    OnAccept();
                }
            }
            else if (e.Key == VirtualKey.Enter)
            {
                AcceptsReturn = true;
            }
            else if (e.Key == VirtualKey.Z)
            {
                var modifiers = WindowContext.KeyModifiers();
                if (modifiers == (VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift))
                {
                    if (Document.CanRedo())
                    {
                        Document.Redo();
                    }

                    e.Handled = true;
                }
            }
            else if (e.Key is VirtualKey.A or VirtualKey.L || (int)e.Key is 188 or 190)
            {
                var modifiers = WindowContext.KeyModifiers();
                if (modifiers == (VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift))
                {
                    return;
                }
            }
            else if (e.Key is VirtualKey.E or VirtualKey.L or VirtualKey.R or VirtualKey.J or VirtualKey.Q)
            {
                var modifiers = WindowContext.KeyModifiers();
                if (modifiers == VirtualKeyModifiers.Control)
                {
                    return;
                }
            }

            if (!e.Handled)
            {
                base.OnKeyDown(e);
            }
        }

        protected virtual bool CanAccept()
        {
            return true;
        }

        protected virtual void OnAccept()
        {
            Accept?.Invoke(this, EventArgs.Empty);
        }

        public event EventHandler TextChangedForRealNoCap;

        public event TypedEventHandler<FormattedTextBox, EventArgs> Accept;

        #region Context menu

        private void OnContextFlyoutOpening(object sender, object e)
        {
            var flyout = ContextFlyout as MenuFlyout;
            if (flyout == null)
            {
                return;
            }

            flyout.Items.Clear();

            var selection = Document.Selection;
            var format = Document.Selection.CharacterFormat;

            var length = Math.Abs(selection.Length) > 0;

            var clipboard = Clipboard.GetContent();

            var clone = Document.Selection.GetClone();
            clone.StartOf(TextRangeUnit.Link, true);
            var mention = TryGetUserId(clone, out long userId);

            flyout.CreateFlyoutItem(Document.CanUndo(), ContextUndo_Click, Strings.TextUndo, Icons.ArrowUndo, VirtualKey.Z);
            flyout.CreateFlyoutItem(Document.CanRedo(), ContextRedo_Click, Strings.Redo, Icons.ArrowRedo, VirtualKey.Y);
            flyout.CreateFlyoutSeparator();
            flyout.CreateFlyoutItem(length && Document.CanCopy(), ContextCut_Click, Strings.Cut, Icons.Cut, VirtualKey.X);
            flyout.CreateFlyoutItem(length && Document.CanCopy(), ContextCopy_Click, Strings.Copy, Icons.DocumentCopy, VirtualKey.C);
            flyout.CreateFlyoutItem(Document.CanPaste(), ContextPaste_Click, Strings.Paste, Icons.ClipboardPaste, VirtualKey.V);
            flyout.CreateFlyoutItem(length, ContextDelete_Click, Strings.Delete);
            flyout.CreateFlyoutSeparator();

            var entities = AllowedEntities & ~FormattedTextEntity.CustomEmoji;
            if (entities != FormattedTextEntity.None)
            {
                var formatting = new MenuFlyoutSubItem
                {
                    Text = Strings.Formatting,
                    Icon = MenuFlyoutHelper.CreateIcon(Icons.TextFont)
                };

                if ((entities & FormattedTextEntity.Quote) != 0)
                {
                    formatting.CreateFlyoutItem(length, ToggleQuote, Strings.Quote, Icons.QuoteBlock);
                }

                if ((entities & FormattedTextEntity.Bold) != 0)
                {
                    formatting.CreateFlyoutItem(length, ToggleBold, Strings.Bold, Icons.TextBold, VirtualKey.B);
                }

                if ((entities & FormattedTextEntity.Italic) != 0)
                {
                    formatting.CreateFlyoutItem(length, ToggleItalic, Strings.Italic, Icons.TextItalic, VirtualKey.I);
                }

                if ((entities & FormattedTextEntity.Underline) != 0)
                {
                    formatting.CreateFlyoutItem(length, ToggleUnderline, Strings.Underline, Icons.TextUnderline, VirtualKey.U);
                }

                if ((entities & FormattedTextEntity.Strikethrough) != 0)
                {
                    formatting.CreateFlyoutItem(length, ToggleStrikethrough, Strings.Strike, Icons.TextStrikethrough, VirtualKey.X, VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift);
                }

                if ((entities & FormattedTextEntity.Mono) != 0)
                {
                    formatting.CreateFlyoutItem(length && format.Name != "Consolas", ToggleMonospace, Strings.Mono, Icons.Code, VirtualKey.M, VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift);
                }

                if ((entities & FormattedTextEntity.Spoiler) != 0)
                {
                    formatting.CreateFlyoutItem(length, ToggleSpoiler, Strings.Spoiler, Icons.Spoiler, VirtualKey.P, VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift);
                }

                formatting.CreateFlyoutSeparator();

                if ((entities & FormattedTextEntity.TextUrl) != 0)
                {
                    formatting.CreateFlyoutItem(!mention, CreateLink, clone.Link.Length > 0 ? Strings.EditLink : Strings.CreateLink, Icons.Link, VirtualKey.K);
                }

                formatting.CreateFlyoutSeparator();
                formatting.CreateFlyoutItem(length && !IsDefaultFormat(selection), ToggleRegular, Strings.Regular, null, VirtualKey.N, VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift);

                flyout.Items.Add(formatting);
            }

            flyout.CreateFlyoutSeparator();
            flyout.CreateFlyoutItem(!IsEmpty, ContextSelectAll_Click, Strings.SelectAll, null, VirtualKey.A);

            if (ProofingMenuFlyout is MenuFlyout proofing && proofing.Items.Count > 0)
            {
                flyout.CreateFlyoutSeparator();
                //flyout.Items.Add(_proofingMenu);

                foreach (var item in proofing.Items)
                {
                    flyout.Items.Add(item);
                }
            }
        }

        private void OnContextFlyoutClosing(FlyoutBase sender, FlyoutBaseClosingEventArgs args)
        {
            _proofingFlyout.Items.Clear();

            if (sender is MenuFlyout flyout)
            {
                flyout.Items.Clear();
            }
        }

        public void ToggleQuote()
        {
            InsertBlockquote(Document.Selection);

            _selectionFlyout.Update(Document.Selection);
        }

        public void ToggleBold()
        {
            Document.BatchDisplayUpdates();
            ClearStyle(Document.Selection, false);
            Document.Selection.CharacterFormat.Bold = FormatEffect.Toggle;
            Document.ApplyDisplayUpdates();

            _selectionFlyout.Update(Document.Selection);
        }

        public void ToggleItalic()
        {
            Document.BatchDisplayUpdates();
            ClearStyle(Document.Selection, false);
            Document.Selection.CharacterFormat.Italic = FormatEffect.Toggle;
            Document.ApplyDisplayUpdates();

            _selectionFlyout.Update(Document.Selection);
        }

        public void ToggleUnderline()
        {
            Document.BatchDisplayUpdates();
            ClearStyle(Document.Selection, false);
            Document.Selection.CharacterFormat.Underline = Document.Selection.CharacterFormat.Underline != UnderlineType.Single ? UnderlineType.Single : UnderlineType.None;
            Document.ApplyDisplayUpdates();

            _selectionFlyout.Update(Document.Selection);
        }

        public void ToggleStrikethrough()
        {
            Document.BatchDisplayUpdates();
            ClearStyle(Document.Selection, false);
            Document.Selection.CharacterFormat.Strikethrough = FormatEffect.Toggle;
            Document.ApplyDisplayUpdates();

            _selectionFlyout.Update(Document.Selection);
        }

        public void ToggleMonospace()
        {
            Document.BatchDisplayUpdates();
            ClearStyle(Document.Selection, true);
            Document.Selection.CharacterFormat.Name = "Consolas";
            Document.ApplyDisplayUpdates();

            _selectionFlyout.Update(Document.Selection);
        }

        public void ToggleSpoiler()
        {
            Document.BatchDisplayUpdates();
            ClearStyle(Document.Selection, false);
            Document.Selection.CharacterFormat.BackgroundColor = Colors.Gray;
            Document.ApplyDisplayUpdates();

            _selectionFlyout.Update(Document.Selection);
        }

        public void ToggleRegular()
        {
            if (Math.Abs(Document.Selection.Length) < 1)
            {
                return;
            }

            Document.BatchDisplayUpdates();
            ClearStyle(Document.Selection, true);
            Document.ApplyDisplayUpdates();
        }

        public FrameworkElement CreateLinkTarget { get; set; }

        public async void CreateLink()
        {
            var range = Document.Selection.GetClone();
            var clone = Document.Selection.GetClone();
            clone.StartOf(TextRangeUnit.Link, true);

            if (clone.Link.Length > 0)
            {
                range.Expand(TextRangeUnit.Link);
            }

            range.GetText(TextGetOptions.NoHidden, out string text);

            var start = Math.Min(range.StartPosition, range.EndPosition);
            var end = Math.Max(range.StartPosition, range.EndPosition);

            var popup = new CreateLinkPopup();
            popup.Text = text;
            popup.Link = range.Link.Trim('"');

            if (CreateLinkTarget != null)
            {
                popup.Target = CreateLinkTarget;
                popup.PreferredPlacement = Microsoft.UI.Xaml.Controls.TeachingTipPlacementMode.TopRight;
            }
            else
            {
                popup.Target = this;
                popup.PreferredPlacement = Microsoft.UI.Xaml.Controls.TeachingTipPlacementMode.Top;
            }

            popup.Width = popup.MinWidth = popup.MaxWidth = 314;
            popup.IsLightDismissEnabled = true;

            var confirm = await popup.ShowQueuedAsync(XamlRoot);
            if (confirm != true || !IsSafe(popup.Text))
            {
                return;
            }

            Document.BatchDisplayUpdates();

            range.SetText(end > start ? TextSetOptions.Unlink : TextSetOptions.None, popup.Text);
            range.SetRange(start, start + popup.Text.Length);
            range.CharacterFormat = Document.GetDefaultCharacterFormat();
            range.Link = $"\"{popup.Link}\"";

            Document.Selection.SetRange(range.EndPosition, range.EndPosition);
            Document.ApplyDisplayUpdates();
        }

        private void ClearStyle(ITextRange range, bool monospace)
        {
            if (monospace)
            {
                var start = Math.Min(range.StartPosition, range.EndPosition);
                var end = Math.Max(range.StartPosition, range.EndPosition);

                range.SetRange(start, end);
                range.CharacterFormat = Document.GetDefaultCharacterFormat();

                range.GetText(TextGetOptions.NoHidden, out string text);
                range.SetText(TextSetOptions.Unlink, text);
                range.SetRange(start, start + text.Length);
            }
            else
            {
                range.CharacterFormat.Name = Document.GetDefaultCharacterFormat().Name;
            }
        }

        protected bool IsDefaultFormat(ITextRange range)
        {
            var start = Document.GetRange(range.StartPosition, range.StartPosition);
            start.MoveEnd(TextRangeUnit.CharacterFormat, 1);

            if (start.EndPosition >= range.EndPosition)
            {
                return IsDefault(range.CharacterFormat);
            }

            return false;
        }

        protected bool IsDefault(ITextCharacterFormat format)
        {
            return AreTheSame(format, Document.GetDefaultCharacterFormat());
        }

        protected bool AreTheSame(ITextCharacterFormat format, ITextCharacterFormat document)
        {
            return document.AllCaps == format.AllCaps &&
                document.BackgroundColor == format.BackgroundColor &&
                document.Bold == format.Bold &&
                document.FontStretch == format.FontStretch &&
                document.FontStyle == format.FontStyle &&
                document.ForegroundColor == format.ForegroundColor &&
                document.Hidden == format.Hidden &&
                document.Italic == format.Italic &&
                document.Kerning == format.Kerning &&
                //document.LanguageTag == format.LanguageTag &&
                document.LinkType == format.LinkType &&
                document.Name == format.Name &&
                document.Outline == format.Outline &&
                document.Position == format.Position &&
                document.ProtectedText == format.ProtectedText &&
                document.Size == format.Size &&
                document.SmallCaps == format.SmallCaps &&
                document.Spacing == format.Spacing &&
                document.Strikethrough == format.Strikethrough &&
                document.Subscript == format.Subscript &&
                document.Superscript == format.Superscript &&
                //document.TextScript == format.TextScript &&
                document.Underline == format.Underline &&
                document.Weight == format.Weight;
        }

        protected bool TryGetUserId(ITextRange range, out long userId)
        {
            var link = range.Link.Trim('"');
            if (link.StartsWith("tg-user://") && long.TryParse(link.Substring("tg-user://".Length), out userId))
            {
                return true;
            }

            userId = 0;
            return false;
        }

        protected bool TryGetEntityType(string link, out TextEntityType type)
        {
            link = link.Trim('"');

            if (link.IsValidUrl())
            {
                type = new TextEntityTypeTextUrl(link);
                return true;
            }
            else if (link.StartsWith("tg-user://") && long.TryParse(link.Substring("tg-user://".Length), out long userId))
            {
                type = new TextEntityTypeMentionName(userId);
                return true;
            }

            type = null;
            return false;
        }

        private void ContextUndo_Click()
        {
            Document.Undo();
        }

        private void ContextRedo_Click()
        {
            Document.Redo();
        }

        private void ContextCut_Click()
        {
            Document.Selection.Cut();
        }

        private void ContextCopy_Click()
        {
            Document.Selection.Copy();
        }

        private void ContextPaste_Click()
        {
            try
            {
                var args = new HandledEventArgs(false);
                var package = Clipboard.GetContent();

                OnPaste(args, package);
            }
            catch
            {
                // All the remote procedure calls must be wrapped in a try-catch block
            }
        }

        private void OnPaste(object sender, TextControlPasteEventArgs e)
        {
            try
            {
                var args = new HandledEventArgs(false);
                var package = Clipboard.GetContent();

                OnPaste(args, package);

                e.Handled = args.Handled;
            }
            catch
            {
                // All the remote procedure calls must be wrapped in a try-catch block
            }
        }

        protected virtual async void OnPaste(HandledEventArgs e, DataPackageView package)
        {
            try
            {
                // If the user tries to paste RTF content from any TOM control (Visual Studio, Word, Wordpad, browsers)
                // we have to handle the pasting operation manually to allow plaintext only.
                if (package.AvailableFormats.Contains(StandardDataFormats.Text) && package.AvailableFormats.Contains("application/x-tl-field-tags"))
                {
                    e.Handled = true;

                    var text = await MessageHelper.PasteTextAsync(package);
                    SetText(text.Text, text.Entities, true);
                }
                else if (package.AvailableFormats.Contains(StandardDataFormats.Text) /*&& package.Contains("Rich Text Format")*/)
                {
                    e.Handled = true;

                    var text = await package.GetTextAsync();
                    var start = Document.Selection.StartPosition;
                    var length = Math.Abs(Document.Selection.Length);

                    if (length > 0 && text.IsValidUrl())
                    {
                        Document.Selection.GetText(TextGetOptions.NoHidden, out string value);
                        SetText(value, new[] { new TextEntity(0, value.Length, new TextEntityTypeTextUrl(text)) }, true);
                    }
                    else
                    {
                        Document.Selection.SetText(TextSetOptions.Unhide, text);
                        Document.Selection.SetRange(start + text.Length, start + text.Length);
                    }
                }
            }
            catch { }
        }

        private void ContextDelete_Click()
        {
            Document.Selection.SetText(TextSetOptions.None, string.Empty);
        }

        private void ContextSelectAll_Click()
        {
            Document.Selection.Expand(TextRangeUnit.Paragraph);
        }

        private void CreateKeyboardAccelerator(VirtualKey key, VirtualKeyModifiers modifiers = VirtualKeyModifiers.Control)
        {
            var accelerator = new KeyboardAccelerator { Modifiers = modifiers, Key = key, ScopeOwner = this };
            accelerator.Invoked += FlyoutAccelerator_Invoked;

            KeyboardAccelerators.Add(accelerator);
        }

        private void FlyoutAccelerator_Invoked(KeyboardAccelerator sender, KeyboardAcceleratorInvokedEventArgs args)
        {
            args.Handled = true;

            var selection = Document.Selection;
            var format = Document.Selection.CharacterFormat;

            var length = Math.Abs(selection.Length) > 0;

            if (sender.Key == VirtualKey.B && sender.Modifiers == VirtualKeyModifiers.Control && length)
            {
                ToggleBold();
            }
            else if (sender.Key == VirtualKey.I && sender.Modifiers == VirtualKeyModifiers.Control && length)
            {
                ToggleItalic();
            }
            else if (sender.Key == VirtualKey.U && sender.Modifiers == VirtualKeyModifiers.Control && length)
            {
                ToggleUnderline();
            }
            else if (sender.Key == VirtualKey.X && sender.Modifiers == (VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift) && length)
            {
                ToggleStrikethrough();
            }
            else if (sender.Key == VirtualKey.M && sender.Modifiers == (VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift) && length && format.Name != "Consolas")
            {
                ToggleMonospace();
            }
            else if (sender.Key == VirtualKey.P && sender.Modifiers == (VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift) && length && format.ForegroundColor != Colors.Gray)
            {
                ToggleSpoiler();
            }
            else if (sender.Key == VirtualKey.K && sender.Modifiers == VirtualKeyModifiers.Control)
            {
                CreateLink();
            }
            else if (sender.Key == VirtualKey.N && sender.Modifiers == (VirtualKeyModifiers.Control | VirtualKeyModifiers.Shift) && length /*&& !IsDefault(format)*/)
            {
                ToggleRegular();
            }
            else if (sender.Key == VirtualKey.X && sender.Modifiers == VirtualKeyModifiers.Menu && Math.Abs(Document.Selection.Length) == 4)
            {
                args.Handled = true;

                Document.Selection.GetText(TextGetOptions.NoHidden, out string hex);

                if (int.TryParse(hex, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out int result))
                {
                    Document.Selection.SetText(TextSetOptions.None, new string((char)result, 1));
                }
            }
        }

        #endregion

        public string Text
        {
            get
            {
                if (IsEmpty)
                {
                    return string.Empty;
                }

                Document.GetText(TextGetOptions.None, out string text);
                return text;
            }
        }

        public FormattedText GetFormattedText(bool clear = false, bool parseMarkdown = true)
        {
            OnGettingFormattedText();

            if (IsEmpty)
            {
                return new FormattedText(string.Empty, Array.Empty<TextEntity>());
            }

            _updateLocked = true;

            Document.BatchDisplayUpdates();
            Document.GetText(TextGetOptions.None, out string value);

            value = value.TrimEnd('\v', '\r');

            var builder = new StringBuilder(value);

            List<TextStyleRun> runs = null;
            TextStyleRun last = null;
            TextEntityType type = default;

            var hidden = 0;
            var flags = default(TextStyle);

            // TODO: reimplement using the same logic as UpdateFormat

            for (int i = 0; i < value.Length; i++)
            {
                flags = default;

                var range = Document.GetRange(i, i + 1);
                if (range.ParagraphFormat.SpaceAfter != 0)
                {
                    flags = TextStyle.Quote;
                }

                if (string.Equals(range.CharacterFormat.Name, "Consolas", StringComparison.OrdinalIgnoreCase))
                {
                    flags |= TextStyle.Monospace;
                }
                else
                {
                    if (range.CharacterFormat.Hidden == FormatEffect.On)
                    {
                        range.Expand(TextRangeUnit.Hidden);
                        builder.Remove(i - hidden, range.Length);

                        hidden += range.Length;
                        i += range.Length - 1;
                        continue;
                    }

                    if (range.CharacterFormat.Bold == FormatEffect.On)
                    {
                        flags |= TextStyle.Bold;
                    }
                    if (range.CharacterFormat.Italic == FormatEffect.On)
                    {
                        flags |= TextStyle.Italic;
                    }
                    if (range.CharacterFormat.Strikethrough == FormatEffect.On)
                    {
                        flags |= TextStyle.Strikethrough;
                    }
                    if (range.CharacterFormat.Underline == UnderlineType.Single)
                    {
                        flags |= TextStyle.Underline;
                    }
                    if (range.CharacterFormat.BackgroundColor == Colors.Gray)
                    {
                        flags |= TextStyle.Spoiler;
                    }

                    if (range.Link.Length > 0 && TryGetEntityType(range.Link, out type))
                    {
                        flags |= TextStyle.Url;
                        flags &= ~TextStyle.Underline;
                    }
                    else
                    {
                        type = null;
                    }
                }

                if (last != null && last.Flags == flags)
                {
                    last.End = i - hidden + 1;
                }
                else
                {
                    if (last != null)