private void Strokes_StrokesChanged(object sender, System.Windows.Ink.StrokeCollectionChangedEventArgs e) { if (e.Added.Count > 0) { tempList.Push(e.Added); } }
/// <summary> /// Event handler associated with the stroke collection. /// </summary> /// <param name="sender">Stroke collection that was modified</param> /// <param name="args">Modification that occurred</param> /// <remarks> /// Update our _strokeInfos cache. We get notified on StrokeCollection.StrokesChangedInternal which /// is raised first so we can assume we're the first delegate in the call chain /// </remarks> private void OnStrokesChanged(object sender, StrokeCollectionChangedEventArgs args) { System.Diagnostics.Debug.Assert((_strokes != null) && (_strokeInfos != null) && (_strokes == sender)); StrokeCollection added = args.Added; StrokeCollection removed = args.Removed; if (added.Count > 0) { int firstIndex = _strokes.IndexOf(added[0]); for (int i = 0; i < added.Count; i++) { _strokeInfos.Insert(firstIndex, new StrokeInfo(added[i])); firstIndex++; } } if (removed.Count > 0) { StrokeCollection localRemoved = new StrokeCollection(removed); //we have to assume that removed strokes can be in any order in _strokes for (int i = 0; i < _strokeInfos.Count && localRemoved.Count > 0;) { bool found = false; for (int j = 0; j < localRemoved.Count; j++) { if (localRemoved[j] == _strokeInfos[i].Stroke) { _strokeInfos.RemoveAt(i); localRemoved.RemoveAt(j); found = true; } } //we didn't find a removed stroke at index i in _strokeInfos, so advance i if (!found) { i++; } } } //validate our cache if (_strokes.Count != _strokeInfos.Count) { Debug.Assert(false, "Benign assert. IncrementalHitTester's _strokeInfos cache is out of sync, rebuilding."); RebuildStrokeInfoCache(); return; } for (int i = 0; i < _strokeInfos.Count; i++) { if (_strokeInfos[i].Stroke != _strokes[i]) { Debug.Assert(false, "Benign assert. IncrementalHitTester's _strokeInfos cache is out of sync, rebuilding."); RebuildStrokeInfoCache(); return; } } }
private void Strokes_StrokesChanged(object sender, System.Windows.Ink.StrokeCollectionChangedEventArgs e) { if (handle) { _added = e.Added; _removed = e.Removed; testiadded.Add(_added); } }
// This function will invoke OnStrokesChanged method. // addedStrokes - the collection which contains the added strokes during the previous op. // removedStrokes - the collection which contains the removed strokes during the previous op. private void RaiseStrokesChanged(StrokeCollection addedStrokes, StrokeCollection removedStrokes, int index) { StrokeCollectionChangedEventArgs eventArgs = new StrokeCollectionChangedEventArgs(addedStrokes, removedStrokes, index); // Invoke OnPropertyChanged OnPropertyChanged(CountName); OnPropertyChanged(IndexerName); // Invoke OnStrokesChanged which will fire the StrokesChanged event AND the CollectionChanged event. OnStrokesChanged(eventArgs); }
private void Strokes_StrokesChanged(object sender, System.Windows.Ink.StrokeCollectionChangedEventArgs e) { if (handle) { addedStrokes.Push(e.Added); removedStrokes.Push(e.Removed); if (e.Added != null) { removedStrokes.Clear(); } } }
/// <summary>Method called on derived classes whenever a drawing attributes /// change has occurred in the stroke references in the collection</summary> /// <param name="e">The change information for the stroke collection</param> /// <remarks>StrokesChanged will not be called when drawing attributes or /// custom attributes are changed. Changes that trigger StrokesChanged /// include packets or points changing, modified tranforms, and stroke objects /// being added or removed from the collection. /// To ensure that events fire for event listeners, derived classes /// should call this method.</remarks> protected virtual void OnStrokesChanged(StrokeCollectionChangedEventArgs e) { if (null == e) { throw new ArgumentNullException("e", SR.Get(SRID.EventArgIsNull)); } //raise our internal event first. This is used by //our Renderer and IncrementalHitTester since if they can assume //they are the first in the delegate chain, they can be optimized //to not have to handle out of order events caused by 3rd party code //getting called first if (this.StrokesChangedInternal != null) { this.StrokesChangedInternal(this, e); } if (this.StrokesChanged != null) { this.StrokesChanged(this, e); } if (_collectionChanged != null) { //raise CollectionChanged. We support the following //NotifyCollectionChangedActions NotifyCollectionChangedEventArgs args = null; if (this.Count == 0) { //Reset Debug.Assert(e.Removed.Count > 0); args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset); } else if (e.Added.Count == 0) { //Remove args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, e.Removed, e.Index); } else if (e.Removed.Count == 0) { //Add args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, e.Added, e.Index); } else { //Replace args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, e.Added, e.Removed, e.Index); } _collectionChanged(this, args); } }
private void StrokeCollection_StrokesChanged(object sender, System.Windows.Ink.StrokeCollectionChangedEventArgs e) { try { if (!_initialized) { return; } RedrawSmallImage(); } catch (Exception ex) { MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error); } }
/// <summary> /// StrokeCollectionChanged event handler /// </summary> private void OnStrokesChanged(object sender, StrokeCollectionChangedEventArgs eventArgs) { System.Diagnostics.Debug.Assert(sender == _strokes); // Read the args StrokeCollection added = eventArgs.Added; StrokeCollection removed = eventArgs.Removed; // Add new strokes foreach (Stroke stroke in added) { // Verify that it's not a dupe if (_visuals.ContainsKey(stroke)) { throw new System.ArgumentException(SR.Get(SRID.DuplicateStrokeAdded)); } // Create a visual for the new stroke and add it to the dictionary StrokeVisual visual = new StrokeVisual(stroke, this); _visuals.Add(stroke, visual); // Start listening on the stroke events StartListeningOnStrokeEvents(visual.Stroke); // Attach it to the visual tree AttachVisual(visual, false /*buildingStrokeCollection*/); } // Deal with removed strokes first foreach (Stroke stroke in removed) { // Verify that the event is in sync with the view StrokeVisual visual = null; if (_visuals.TryGetValue(stroke, out visual)) { // get rid of both the visual and the stroke DetachVisual(visual); StopListeningOnStrokeEvents(visual.Stroke); _visuals.Remove(stroke); } else { throw new System.ArgumentException(SR.Get(SRID.UnknownStroke3)); } } }
/// <summary> /// Our own internal listener for strokes changed. /// This is used so that if someone deletes or modifies a stroke /// we are currently displaying for selection, we can update our size /// </summary> private void OnStrokeCollectionChanged(object target, StrokeCollectionChangedEventArgs e) { // If the strokes only get added to the InkCanvas, we don't have to update our internal selected strokes. if ( e.Added.Count != 0 && e.Removed.Count == 0 ) { return; } foreach (Stroke s in e.Removed) { if ( SelectedStrokes.Contains(s) ) { s.Invalidated -= new EventHandler(this.OnStrokeInvalidated); s.IsSelected = false; // Now remove the stroke from our private collection. SelectedStrokes.Remove(s); } } // Mark the strokes change _areStrokesChanged = true; UpdateSelectionAdorner(); }
/// <summary> /// StrokeCollectionChanged event handler /// </summary> private void OnStrokesChanged(object sender, StrokeCollectionChangedEventArgs eventArgs) { System.Diagnostics.Debug.Assert(sender == _strokes); // Read the args StrokeCollection added = eventArgs.Added; StrokeCollection removed = eventArgs.Removed; // Add new strokes foreach (Stroke stroke in added) { // Verify that it's not a dupe if (_visuals.ContainsKey(stroke)) { throw new System.ArgumentException(SR.Get(SRID.DuplicateStrokeAdded)); } // Create a visual for the new stroke and add it to the dictionary StrokeVisual visual = new StrokeVisual(stroke, this); _visuals.Add(stroke, visual); // Start listening on the stroke events StartListeningOnStrokeEvents(visual.Stroke); // Attach it to the visual tree AttachVisual(visual, false/*buildingStrokeCollection*/); } // Deal with removed strokes first foreach (Stroke stroke in removed) { // Verify that the event is in [....] with the view StrokeVisual visual = null; if (_visuals.TryGetValue(stroke, out visual)) { // get rid of both the visual and the stroke DetachVisual(visual); StopListeningOnStrokeEvents(visual.Stroke); _visuals.Remove(stroke); } else { throw new System.ArgumentException(SR.Get(SRID.UnknownStroke3)); } } }
/// <summary> /// Change is not allowed. We would override SetItem, InsertItem etc but /// they need to be sealed on StrokeCollection to prevent dupes from being added /// </summary> /// <param name="e"></param> protected override void OnStrokesChanged(StrokeCollectionChangedEventArgs e) { throw new NotSupportedException(SR.Get(SRID.StrokeCollectionIsReadOnly)); }
private void OnStrokesChanged(object sender, StrokeCollectionChangedEventArgs e) { // Update the ink data of the ink analyzer. if (e.Removed.Count > 0) { foreach (Stroke stroke in e.Removed) { //we're removing this stroke so we don't need to listen //to StylusPointsChanged anymore stroke.StylusPointsChanged -= OnStrokeStylusPointsChanged; } circuitInkCanvas.InkAnalyzer.RemoveStrokes(e.Removed); } if (e.Added.Count > 0) { foreach (Stroke stroke in e.Added) { //listen for StylusPointsChanged, which can happen //during move and resize operations stroke.StylusPointsChanged += OnStrokeStylusPointsChanged; } circuitInkCanvas.InkAnalyzer.AddStrokes(e.Added); circuitInkCanvas.InkAnalyzer.SetStrokesType(e.Added, StrokeType.Unspecified); } circuitInkCanvas.InkAnalyzer.BackgroundAnalyze(); }
protected virtual new void OnStrokesChanged(StrokeCollectionChangedEventArgs e) { }
/// <summary> /// Event handler associated with the stroke collection. /// </summary> /// <param name="sender">Stroke collection that was modified</param> /// <param name="args">Modification that occurred</param> /// <remarks> /// Update our _strokeInfos cache. We get notified on StrokeCollection.StrokesChangedInternal which /// is raised first so we can assume we're the first delegate in the call chain /// </remarks> private void OnStrokesChanged(object sender, StrokeCollectionChangedEventArgs args) { System.Diagnostics.Debug.Assert((_strokes != null) && (_strokeInfos != null) && (_strokes == sender)); StrokeCollection added = args.Added; StrokeCollection removed = args.Removed; if (added.Count > 0) { int firstIndex = _strokes.IndexOf(added[0]); for (int i = 0; i < added.Count; i++) { _strokeInfos.Insert(firstIndex, new StrokeInfo(added[i])); firstIndex++; } } if (removed.Count > 0) { StrokeCollection localRemoved = new StrokeCollection(removed); //we have to assume that removed strokes can be in any order in _strokes for (int i = 0; i < _strokeInfos.Count && localRemoved.Count > 0; ) { bool found = false; for (int j = 0; j < localRemoved.Count; j++) { if (localRemoved[j] == _strokeInfos[i].Stroke) { _strokeInfos.RemoveAt(i); localRemoved.RemoveAt(j); found = true; } } //we didn't find a removed stroke at index i in _strokeInfos, so advance i if (!found) { i++; } } } //validate our cache if (_strokes.Count != _strokeInfos.Count) { Debug.Assert(false, "Benign assert. IncrementalHitTester's _strokeInfos cache is out of [....], rebuilding."); RebuildStrokeInfoCache(); return; } for (int i = 0; i < _strokeInfos.Count; i++) { if (_strokeInfos[i].Stroke != _strokes[i]) { Debug.Assert(false, "Benign assert. IncrementalHitTester's _strokeInfos cache is out of [....], rebuilding."); RebuildStrokeInfoCache(); return; } } }
/// <summary> /// StrokeCollectionChanged event handler /// </summary> private void OnStrokesChanged(object sender, StrokeCollectionChangedEventArgs eventArgs) { System.Diagnostics.Debug.Assert(sender == this.Strokes); SetStrokeChangedHandlers(eventArgs.Added, eventArgs.Removed); OnStrokeChanged(this, EventArgs.Empty); }
private void Strokes_StrokesChanged(object sender, System.Windows.Ink.StrokeCollectionChangedEventArgs e) { this.InitStrokes(e.Added, false); }
void Strokes_StrokesChanged(object sender, StrokeCollectionChangedEventArgs e) { foreach (Stroke stroke in e.Added) { if (!graphAnalyzer.newStroke(stroke)) { inkAnalyzer.AddStroke(stroke); } AutocorrectHandleAddStroke(stroke); } double ymax = InkUtils.StrokeYMax(e.Added); if (ymax > MainInkCanvas.ActualHeight - 300.0) MainInkCanvas.Height = ymax + 800.0; foreach (Stroke stroke in e.Removed) { graphAnalyzer.removeStroke(stroke); // If we erase a word and try to replace it with autocorrect // suggestions, there's no good way to define the behavior // so just hide the suggestions. suggestionsBox.Visibility = Visibility.Collapsed; inkAnalyzer.RemoveStroke(stroke); } }
/** * This method is called as you start drawing, for each change * */ private void canvasStrokesChanged(object sender, StrokeCollectionChangedEventArgs e) { if (sender as StrokeCollection != null) { StrokeCollection strokes = (StrokeCollection)sender; for(int i=0; i<strokes.Count ; i++){ Console.WriteLine(); Stroke s = strokes[i]; //ensures we don't end up hooking our event handler multiple times :) s.StylusPointsChanged -= new EventHandler(s_StylusPointsChanged); s.StylusPointsChanged += new EventHandler(s_StylusPointsChanged); } } }