Added support for limiting max tokens in TokenizingTextBox

Microsoft.Toolkit.Uwp.SampleApp/SamplePages/TokenizingTextBox/TokenizingTextBoxXaml.bind

@@ -30,16 +30,20 @@
       <RowDefinition/>
     </Grid.RowDefinitions>
     <StackPanel>
-      <TextBlock FontSize="32" Text="Select Actions"
-                 Margin="0,0,0,4"/>
+      <TextBlock FontSize="32" Margin="0,0,0,4">
+        <Run Text="Select up to" />
+        <Run Text="{Binding MaxTokens, ElementName=TokenBox, Mode=OneWay}" />
+        <Run Text="actions" />
+      </TextBlock>
       <controls:TokenizingTextBox
           x:Name="TokenBox"
           PlaceholderText="Add Actions"
           QueryIcon="{ui:SymbolIconSource Symbol=Setting}"
           MaxHeight="104"
           HorizontalAlignment="Stretch"
           TextMemberPath="Text"
-          TokenDelimiter=",">
+          TokenDelimiter=","
+          MaxTokens="3">
         <controls:TokenizingTextBox.SuggestedItemTemplate>
           <DataTemplate>
             <StackPanel Orientation="Horizontal">

Microsoft.Toolkit.Uwp.UI.Controls.Input/TokenizingTextBox/TokenizingTextBox.Properties.cs

@@ -157,6 +157,37 @@ private static void TextPropertyChanged(DependencyObject d, DependencyPropertyCh
             typeof(TokenizingTextBox),
             new PropertyMetadata(false));
 
+        /// <summary>
+        /// Identifies the <see cref="MaxTokens"/> property.
+        /// </summary>
+        public static readonly DependencyProperty MaxTokensProperty = DependencyProperty.Register(
+            nameof(MaxTokens),
+            typeof(int),
+            typeof(TokenizingTextBox),
+            new PropertyMetadata(null, OnMaxTokensChanged));
+
+        private static void OnMaxTokensChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is TokenizingTextBox ttb && ttb.ReadLocalValue(MaxTokensProperty) != DependencyProperty.UnsetValue && e.NewValue is int newMaxTokens)
+            {
+                var tokenCount = ttb._innerItemsSource.ItemsSource.Count;
+                if (tokenCount > 0 && tokenCount > newMaxTokens)
+                {
+                    int tokensToRemove = tokenCount - Math.Max(newMaxTokens, 0);
+
+                    // Start at the end, remove any extra tokens.
+                    for (var i = tokenCount; i >= tokenCount - tokensToRemove; --i)
+                    {
+                        var token = ttb._innerItemsSource.ItemsSource[i - 1];
+
+                        // Force remove the items. No warning and no option to cancel.
+                        ttb._innerItemsSource.Remove(token);
+                        ttb.TokenItemRemoved?.Invoke(ttb, token);
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Gets or sets the Style for the contained AutoSuggestBox template part.
         /// </summary>
@@ -303,5 +334,14 @@ public string SelectedTokenText
                 return PrepareSelectionForClipboard();
             }
         }
+
+        /// <summary>
+        /// Gets or sets the maximum number of token results allowed at a time.
+        /// </summary>
+        public int MaxTokens
+        {
+            get => (int)GetValue(MaxTokensProperty);
+            set => SetValue(MaxTokensProperty, value);
+        }
     }
-}
+}

Microsoft.Toolkit.Uwp.UI.Controls.Input/TokenizingTextBox/TokenizingTextBox.cs

@@ -77,6 +77,16 @@ private void ItemsSource_PropertyChanged(DependencyObject sender, DependencyProp
             if (ItemsSource != null && ItemsSource.GetType() != typeof(InterspersedObservableCollection))
             {
                 _innerItemsSource = new InterspersedObservableCollection(ItemsSource);
+
+                if (ReadLocalValue(MaxTokensProperty) != DependencyProperty.UnsetValue && _innerItemsSource.ItemsSource.Count > MaxTokens)
+                {
+                    // Reduce down to the max as necessary.
+                    for (var i = _innerItemsSource.ItemsSource.Count - 1; i >= Math.Max(MaxTokens, 0); --i)
+                    {
+                        _innerItemsSource.Remove(_innerItemsSource[i]);
+                    }
+                }
+
                 _currentTextEdit = _lastTextEdit = new PretokenStringContainer(true);
                 _innerItemsSource.Insert(_innerItemsSource.Count, _currentTextEdit);
                 ItemsSource = _innerItemsSource;
@@ -278,18 +288,16 @@ void WaitForLoad(object s, RoutedEventArgs eargs)
                 }
                 else
                 {
-                    // TODO: It looks like we're setting selection and focus together on items? Not sure if that's what we want...
-                    // If that's the case, don't think this code will ever be called?
-
-                    //// TODO: Behavior question: if no items selected (just focus) does it just go to our last active textbox?
-                    //// Community voted that typing in the end box made sense
-
+                    // If no items are selected, send input to the last active string container.
+                    // This code is only fires during an edgecase where an item is in the process of being deleted and the user inputs a character before the focus has been redirected to a string container.
                     if (_innerItemsSource[_innerItemsSource.Count - 1] is ITokenStringContainer textToken)
                     {
                         var last = ContainerFromIndex(Items.Count - 1) as TokenizingTextBoxItem; // Should be our last text box
-                        var position = last._autoSuggestTextBox.SelectionStart;
-                        textToken.Text = last._autoSuggestTextBox.Text.Substring(0, position) + args.Character +
-                                         last._autoSuggestTextBox.Text.Substring(position);
+                        var text = last._autoSuggestTextBox.Text;
+                        var selectionStart = last._autoSuggestTextBox.SelectionStart;
+                        var position = selectionStart > text.Length ? text.Length : selectionStart;
+                        textToken.Text = text.Substring(0, position) + args.Character +
+                                         text.Substring(position);
 
                         last._autoSuggestTextBox.SelectionStart = position + 1; // Set position to after our new character inserted
 
@@ -432,6 +440,12 @@ public async Task ClearAsync()
 
         internal async Task AddTokenAsync(object data, bool? atEnd = null)
         {
+            if (ReadLocalValue(MaxTokensProperty) != DependencyProperty.UnsetValue && MaxTokens <= 0)
+            {
+                // No tokens for you
+                return;
+            }
+
             if (data is string str && TokenItemAdding != null)
             {
                 var tiaea = new TokenItemAddingEventArgs(str);
@@ -451,6 +465,26 @@ internal async Task AddTokenAsync(object data, bool? atEnd = null)
             // If we've been typing in the last box, just add this to the end of our collection
             if (atEnd == true || _currentTextEdit == _lastTextEdit)
             {
+                if (ReadLocalValue(MaxTokensProperty) != DependencyProperty.UnsetValue && _innerItemsSource.ItemsSource.Count >= MaxTokens)
+                {
+                    // Remove tokens from the end until below the max number.
+                    for (var i = _innerItemsSource.Count - 2; i >= 0; --i)
+                    {
+                        var item = _innerItemsSource[i];
+                        if (item is not ITokenStringContainer)
+                        {
+                            _innerItemsSource.Remove(item);
+                            TokenItemRemoved?.Invoke(this, item);
+
+                            // Keep going until we are below the max.
+                            if (_innerItemsSource.ItemsSource.Count < MaxTokens)
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+
                 _innerItemsSource.InsertAt(_innerItemsSource.Count - 1, data);
             }
             else
@@ -459,6 +493,26 @@ internal async Task AddTokenAsync(object data, bool? atEnd = null)
                 var edit = _currentTextEdit;
                 var index = _innerItemsSource.IndexOf(edit);
 
+                if (ReadLocalValue(MaxTokensProperty) != DependencyProperty.UnsetValue && _innerItemsSource.ItemsSource.Count >= MaxTokens)
+                {
+                    // Find the next token and remove it, until below the max number of tokens.
+                    for (var i = index; i < _innerItemsSource.Count;  i++)
+                    {
+                        var item = _innerItemsSource[i];
+                        if (item is not ITokenStringContainer)
+                        {
+                            _innerItemsSource.Remove(item);
+                            TokenItemRemoved?.Invoke(this, item);
+
+                            // Keep going until we are below the max.
+                            if (_innerItemsSource.ItemsSource.Count < MaxTokens)
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+
                 // Insert our new data item at the location of our textbox
                 _innerItemsSource.InsertAt(index, data);
 

UnitTests/UnitTests.UWP/UI/Controls/Test_TokenizingTextBox_General.cs

@@ -63,5 +63,48 @@ public void Test_Clear()
 
             Assert.AreEqual(tokenBox.Items.Count, 5, "Cancelled Clear Failed ");
         }
+
+        [TestCategory("Test_TokenizingTextBox_General")]
+        [UITestMethod]
+        public void Test_MaxTokens()
+        {
+            var maxTokens = 2;
+
+            var treeRoot = XamlReader.Load(
+$@"<Page
+    xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation""
+    xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml""
+    xmlns:controls=""using:Microsoft.Toolkit.Uwp.UI.Controls"">
+
+    <controls:TokenizingTextBox x:Name=""tokenboxname"" MaxTokens=""{maxTokens}"">
+    </controls:TokenizingTextBox>
+
+</Page>") as FrameworkElement;
+
+            Assert.IsNotNull(treeRoot, "Could not load XAML tree.");
+
+            var tokenBox = treeRoot.FindChild("tokenboxname") as TokenizingTextBox;
+
+            Assert.IsNotNull(tokenBox, "Could not find TokenizingTextBox in tree.");
+
+            var startingItemsCount = tokenBox.Items.Count;
+
+            tokenBox.AddTokenItem("TokenItem1");
+            tokenBox.AddTokenItem("TokenItem2");
+
+            Assert.AreEqual(startingItemsCount + maxTokens, tokenBox.Items.Count, "Token Add failed");
+            Assert.AreEqual("TokenItem1", tokenBox.Items[0]);
+            Assert.AreEqual("TokenItem2", tokenBox.Items[1]);
+
+            tokenBox.AddTokenItem("TokenItem3");
+
+            Assert.AreEqual(startingItemsCount + maxTokens, tokenBox.Items.Count, "Token Replace failed");
+            Assert.AreEqual("TokenItem1", tokenBox.Items[0]);
+            Assert.AreEqual("TokenItem3", tokenBox.Items[1]);
+
+            tokenBox.MaxTokens = 1;
+
+            Assert.AreEqual(1, tokenBox.Items.Count);
+        }
     }
 }