public SelectionMovedOrResizedStroke(CommandStack commandStack, StrokeCollection selection, Rect newrect, Rect oldrect, int editingOperationCount)
			: base(commandStack) {
			_selection = selection;
			_newrect = newrect;
			_oldrect = oldrect;
			_editingOperationCount = editingOperationCount;
		}

 private void CheckOutputValue(Rect rect, String recognizedCharacter, bool isError, StrokeCollection removedStrokes)
 {
     //Check out if it is header box
     if (!_truthTable.IsHeaderBox(rect))
     {
         if (recognizedCharacter.Equals("1") || recognizedCharacter.Equals("l")
             || recognizedCharacter.Equals("|"))
         {
             _truthTable.insertValue(rect, "1");
         }
         else if (recognizedCharacter.Equals("0") || recognizedCharacter.Equals("O"))
         {
             _truthTable.insertValue(rect, "0");
         }
         else
         {
             _truthTable.DisplayInputErrorInfo(rect, removedStrokes);
         }
     }else {
         if (!isError)
         {
             if (_truthTable.default_terms_names.Contains(recognizedCharacter))
             {
                 _truthTable.insertValue(rect, recognizedCharacter);
             }
             else {
                 _truthTable.DisplayInputErrorInfo(rect, removedStrokes);
             }
         }
         else {
             _truthTable.DisplayInputErrorInfo(rect, removedStrokes);
         }      
     }
 }

 public SelectionAdorner(StrokeCollection selectedStrokes, InkCanvas inkcanvas)
 {
     InitializeComponent();
     referencedStrokes = selectedStrokes;
     referencedCanvas = inkcanvas;
     setupSelectionAdorner();
 }

 public StrokeCollection Representation()
 {
     StrokeCollection strokes = new StrokeCollection();
     foreach (var data in stylusStrokes)
         strokes.Add(data.Representation());
     return strokes;
 }

		public void Empty_HitTest ()
		{
			StrokeCollection sc = new StrokeCollection ();
			Assert.Throws<ArgumentException> (delegate {
				sc.HitTest (null);
			}, "HitTest-null");
		}

		public void Empty_GetBounds ()
		{
			StrokeCollection sc = new StrokeCollection ();
			Assert.Throws<ArgumentException> (delegate {
				sc.GetBounds ();
			}, "GetBounds");
		}

		public UserDefinedShape()
		{
			if (_strokes == null) {
				_strokes = new StrokeCollection();
			}
			(_strokes as INotifyCollectionChanged).CollectionChanged += StrokesChangedEventHandler;
		}

        private void updateStrokePrivacy(object obj)
        {
            ClearAdorners();

            var newStrokes = new StrokeCollection(Strokes.Select(s => (Stroke)new PrivateAwareStroke(s, target)));
            Strokes.Clear();
            Strokes.Add(newStrokes);
        }

		private void AddAllStrokesAtOriginalIndex(StrokeCollection toBeAdded) {
			foreach (Stroke stroke in toBeAdded) {
				int strokeIndex = (int)stroke.GetPropertyData(STROKE_INDEX_PROPERTY);
				if (strokeIndex > _commandStack.StrokeCollection.Count)
					strokeIndex = _commandStack.StrokeCollection.Count;
				_commandStack.StrokeCollection.Insert(strokeIndex, stroke);
			}
		}

		public StrokesAddedOrRemovedStroke(CommandStack commandStack, InkCanvasEditingMode editingMode, StrokeCollection added, StrokeCollection removed, int editingOperationCount)
			: base(commandStack) {
			_editingMode = editingMode;

			_added = added;
			_removed = removed;

			_editingOperationCount = editingOperationCount;
		}

        public InkQueryRegionStruct(StrokeCollection strokes)
        {
            _equalStrokes = strokes;
            _children = new VisualCollection(this);

            EqualRect = strokes.GetBounds();
            LeftSideRegionRect = new Rect(new Point(EqualRect.TopLeft.X - EqualRect.Width * 5, EqualRect.TopLeft.Y - EqualRect.Height * 2), new Size(EqualRect.Width * 4, EqualRect.Height * 4));
            RightSideRegionRect = new Rect(new Point(EqualRect.BottomRight.X + EqualRect.Width, EqualRect.BottomRight.Y - EqualRect.Height * 3), new Size(EqualRect.Width * 4, EqualRect.Height * 4));
        }

 /// <summary>Constructor</summary> 
 public StrokeCollectionChangedEventArgs(StrokeCollection added, StrokeCollection removed)
 {
     if ( added == null && removed == null )
     { 
         throw new ArgumentException(SR.Get(SRID.CannotBothBeNull, "added", "removed"));
     } 
     _added = ( added == null ) ? null : new StrokeCollection.ReadOnlyStrokeCollection(added); 
     _removed = ( removed == null ) ? null : new StrokeCollection.ReadOnlyStrokeCollection(removed);
 } 

 /// <summary>
 /// Initialization.
 /// </summary>
 /// <param name="strokes"></param>
 public DoCommandStack(StrokeCollection strokes)
 {
     if (strokes == null)
     {
         return;
     }
     _strokeCollection = strokes;
     _undoStack = new Stack<CommandItem>();
     _redoStack = new Stack<CommandItem>();
     _disableChangeTracking = false;
 }

 public void RefreshPattern()
 {
     if (Pattern != null) {
         StrokeCollection collection = new StrokeCollection();
         for (int i = 0; i < Count; i++) {
             foreach (var stroke in Pattern[i]) {
                 collection.Add(stroke);
             }
         }
         inkPresenter.Strokes = collection;
     }
 }

        //local calls only 
        public void extractGeomtry(StrokeCollection strokes, Rect bounds)
        {
            _bounds = bounds;

            _strokes = strokes.Clone();
            foreach (Stroke strk in strokes)
            {                
                var brush = new SolidColorBrush(strk.DrawingAttributes.Color);             
                drawGrp.Children.Add(  new GeometryDrawing( brush, null, strk.GetGeometry())  );
            }

            SetMarkers();
            SetBounds();
        }

        public Whiteboard()
        {
            base.CanScale = true;

            _grid = new Grid()
            {
                VerticalAlignment = System.Windows.VerticalAlignment.Stretch,
                Background = new SolidColorBrush(Color.FromArgb(200, 50, 50, 50))
            };
            _grid.RowDefinitions.Add(new RowDefinition() { Height = GridLength.Auto });
            _grid.RowDefinitions.Add(new RowDefinition() { Height = new GridLength(1, GridUnitType.Star) });
            base.Content = _grid;

            _canvas = new SurfaceInkCanvas()
            {
                Background = new SolidColorBrush(Colors.Black),
                VerticalAlignment = System.Windows.VerticalAlignment.Stretch,
                Margin = new Thickness(12, 0, 12, 12)
            };

            _privateStrokeCollection = _canvas.Strokes;

            Grid.SetRow(_canvas, 1);
            _grid.Children.Add(_canvas);

            StackPanel buttons = new StackPanel()
            {
                Orientation = System.Windows.Controls.Orientation.Horizontal,
                HorizontalAlignment = System.Windows.HorizontalAlignment.Right
            };
            Grid.SetRow(buttons, 0);
            _grid.Children.Add(buttons);

            _eraseButton = new MyButton("Erase.png");
            _eraseButton.SelectedChanged += new EventHandler(_eraseButton_SelectedChanged);
            buttons.Children.Add(_eraseButton);

            _drawButton = new MyButton("167-Painting.png") { IsSelected = true };
            _drawButton.SelectedChanged += new EventHandler(_drawButton_SelectedChanged);
            buttons.Children.Add(_drawButton);

            _typeButton = new SwitchButton("109-AdminUser.png", "108-Group.png")
            {
                Margin = new Thickness(12,0,0,0)
            };
            _typeButton.DisplayedSwitched += new EventHandler(_typeButton_DisplayedSwitched);
            buttons.Children.Add(_typeButton);
        }

        public static XElement StrokestoXML(StrokeCollection mystrokes)
        {
            string xmlnsString = "http://schemas.microsoft.com/client/2007";

            XNamespace xmlns = xmlnsString;
            XElement XMLStrokes = new XElement(xmlns + "StrokeCollection",
                new XAttribute("xmlns", xmlnsString));

            //create stroke, then add to collection element
            XElement mystroke;
            foreach (Stroke s in mystrokes)
            {
                mystroke = new XElement(xmlns + "Stroke",
                  new XElement(xmlns + "Stroke.DrawingAttributes",
                    new XElement(xmlns + "DrawingAttributes",
                       new XElement("Color",
                                new XAttribute("A", s.DrawingAttributes.Color.A),
                                new XAttribute("R", s.DrawingAttributes.Color.R),
                                new XAttribute("G", s.DrawingAttributes.Color.G),
                                new XAttribute("B", s.DrawingAttributes.Color.B)
                            ),
                       new XElement("OutlineColor",
                                new XAttribute("A", s.DrawingAttributes.OutlineColor.A),
                                new XAttribute("R", s.DrawingAttributes.OutlineColor.R),
                                new XAttribute("G", s.DrawingAttributes.OutlineColor.G),
                                new XAttribute("B", s.DrawingAttributes.OutlineColor.B)
                            ),
                       new XAttribute("Width", s.DrawingAttributes.Width),
                       new XAttribute("Height", s.DrawingAttributes.Height))));

                //create points separately then add to mystroke XElement
                XElement myPoints = new XElement(xmlns + "Stroke.StylusPoints");
                foreach (StylusPoint sp in s.StylusPoints)
                {
                    XElement mypoint = new XElement(xmlns + "StylusPoint",
                      new XAttribute("X", sp.X.ToString()),
                      new XAttribute("Y", sp.Y.ToString()));
                    //add the new point to the points collection of the stroke
                    myPoints.Add(mypoint);
                }
                //add the new points collection to the stroke
                mystroke.Add(myPoints);
                //add the stroke to the collection
                XMLStrokes.Add(mystroke);
            }
            return XMLStrokes;
        }

 public string StrokesToBase64(StrokeCollection inkStrokes)
 {
     try
     {
         using (MemoryStream ms = new MemoryStream())
         {
             // Save strokes from InkCanvas to a stream as ISF.
             inkStrokes.Save(ms);
             // Convert bytes from stream to Base64 text.
             byte[] isfBytes = ms.ToArray();
             return Convert.ToBase64String(isfBytes,
                    Base64FormattingOptions.InsertLineBreaks);
         }
     }
     catch
     {
         return "";
     }
 }

        private StrokeCollection GetStrokeCollectionFromPoints(dynamic strokePoints)
        {
            var strokeCollection = new StrokeCollection();

            foreach (var stroke in strokePoints.Strokes)
            {
                var points = new StylusPointCollection();

                foreach (var point in stroke.Points)
                {
                    var x = (float)point.X;
                    var y = (float)point.Y;

                    points.Add(new StylusPoint(x, y));
                }

                strokeCollection.Add(new Stroke(points));
            }

            return strokeCollection;
        }

 public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 {
     var strokeCollection = new StrokeCollection();
     var inkData = value as byte[];
     if (inkData != null)
     {
         Stream strokesStream = StreamHelper.FromArray(inkData);
         if (strokesStream != null && strokesStream.Length > 1)
         {
             strokesStream.Seek(0, 0);
             try
             {
                 strokeCollection = new StrokeCollection(strokesStream);
             }
             catch
             {
             }
         }
     }
     return strokeCollection;
 }