Пример #1
0
        private void DupliquerSelection(object sender, RoutedEventArgs e)
        {
            VueModele           vueModele       = ((VueModele)this.DataContext);
            List <CustomStroke> selectedStrokes = vueModele.Traits.Where(stroke => ((CustomStroke)stroke).isSelected()).Cast <CustomStroke>().ToList();

            //If no stroke is selected ==> Cut/Paste operation
            if (selectedStrokes.Count == 0)
            {
                vueModele.Traits.Add(ClipBoard);
                ClipBoard.ToList().ForEach(stroke =>
                {
                    EditionSocket.AddStroke(((Savable)stroke).toJson());
                    Editeur.instance.Do(new NewStroke(((CustomStroke)stroke).Id.ToString(), ((Savable)stroke).toJson()));
                });
                ClipBoard.Clear();
            }
            else
            {
                EditionSocket.UnlockStrokes();
                vueModele.editeur.EditingStroke = null;
                selectedStrokes.ForEach(stroke =>
                {
                    CustomStroke duplicate = stroke.Duplicate();
                    ((VueModele)this.DataContext).Traits.Add(duplicate);
                    duplicate.Select();
                    EditionSocket.AddStroke(((Savable)duplicate).toJson());
                    Editeur.instance.Do(new NewStroke(((CustomStroke)duplicate).Id.ToString(), ((Savable)duplicate).toJson()));
                });
            }
        }
Пример #2
0
        protected override void DrawCore(DrawingContext drawingContext, DrawingAttributes drawingAttributes)
        {
            CustomStroke parent = this.strokes.get(this.ParentId);

            if (parent is ShapeStroke)
            {
                drawingContext.PushTransform(new RotateTransform(((ShapeStroke)parent).Rotation, ((ShapeStroke)parent).Center.X, ((ShapeStroke)parent).Center.Y));
            }

            DrawingAttributes originalDa = drawingAttributes.Clone();
            Pen pen = new Pen(new SolidColorBrush(Colors.Gray), 1.5);

            Point up = this.StylusPoints[0].ToPoint();

            up.Y = up.Y - 6;
            Point down = this.StylusPoints[0].ToPoint();

            down.Y = down.Y + 6;
            Point left = this.StylusPoints[0].ToPoint();

            left.X = left.X - 6;
            Point right = this.StylusPoints[0].ToPoint();

            right.X = right.X + 6;
            drawingContext.DrawLine(pen, left, right);
            drawingContext.DrawLine(pen, up, down);

            if (parent is ShapeStroke)
            {
                drawingContext.Pop();
            }
        }
        public void setParameters(CustomStroke stroke)
        {
            _label       = stroke.name;
            _borderColor = (Color)ColorConverter.ConvertFromString((stroke as ShapeStroke).shapeStyle.borderColor);
            _fillColor   = (Color)ColorConverter.ConvertFromString((stroke as ShapeStroke).shapeStyle.backgroundColor);
            switch ((stroke as ShapeStroke).shapeStyle.borderStyle)
            {
            case (int)LineStyles.FULL:
                _lineStyle = "Full";
                break;

            case (int)LineStyles.DASHED:
                _lineStyle = "Dashed";
                break;

            case (int)LineStyles.DOTTED:
                _lineStyle = "Dotted";
                break;

            default:
                _lineStyle = "Full";
                break;
            }
            _lineStylesList = new List <string> {
                "Full", "Dashed"
            };
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Label"));
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("BorderColor"));
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("FillColor"));
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("LineStyle"));
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("LineStylesList"));
        }
Пример #4
0
        private void MergeStrokes(DrawingAttributes attr)
        {
            try
            {
                StylusPointCollection points          = new StylusPointCollection();
                StrokeCollection      strokesToRemove = new StrokeCollection();

                foreach (CustomStroke trait in Traits)
                {
                    if (trait.uid == currentStrokeId)
                    {
                        points.Add(trait.StylusPoints);
                        strokesToRemove.Add(trait);
                    }
                }

                CustomStroke fullStroke = new CustomStroke(points, attr);
                fullStroke.uid = currentStrokeId;

                App.Current.Dispatcher.Invoke(delegate
                {
                    Traits.Add(fullStroke);
                    Traits.Remove(strokesToRemove);
                });

                currentStrokeId = Guid.NewGuid();
            }
            catch (Exception)
            {
                App.Current.Dispatcher.Invoke(delegate
                {
                    Traits.Clear();
                });
            }
        }
Пример #5
0
        private void Canvas_PreviewMouseRightButtonUp(object sender, MouseButtonEventArgs e)
        {
            Point        point   = e.GetPosition((IInputElement)sender);
            CustomStroke clicked = null;

            Canvas.Strokes.ToList().ForEach(stroke =>
            {
                CustomStroke customStroke = (CustomStroke)stroke;
                if (!customStroke.isSelectable())
                {
                    return;
                }
                if (!customStroke.HitTest(point))
                {
                    return;
                }

                clicked = customStroke;
            });

            if (clicked != null)
            {
                ((VueModele)this.DataContext).Edit.Execute(clicked);
            }
        }
Пример #6
0
        public void SendNewStroke(CustomStroke stroke)
        {
            //drawingService.createStroke();
            Coordinates coordinates = new Coordinates(stroke.StylusPoints[0].X, stroke.StylusPoints[0].Y);
            ShapeStyle  shapeStyle  = new ShapeStyle();

            shapeStyle.coordinates = coordinates;
        }
Пример #7
0
 private void SetStroke()
 {
     if (_Stroke != null)
     {
         InkCanvas_StrokeCollected(_InkCanvas, new InkCanvasStrokeCollectedEventArgs(_Stroke));
         _Stroke = null;
     }
 }
Пример #8
0
        private void OpenFile(string _FilePath) //Loaddata
        {
            if (!File.Exists(_FilePath))
            {
                Trace.WriteLine("file not exists " + _FilePath); return;
            }
            byte[]       _Buffer       = File.ReadAllBytes(_FilePath);
            MemoryStream _MemoryStream = new MemoryStream(_Buffer);

            _MapDatabase = (MapDatabase)_XmlSerializer.Deserialize(_MemoryStream);

            _InkCanvas.Strokes.Clear();

            InkCanvas.SetLeft(_CStartPos, _MapDatabase._CStartPos.X);
            InkCanvas.SetTop(_CStartPos, _MapDatabase._CStartPos.Y);
            InkCanvas.SetLeft(_TStartPos, _MapDatabase._TStartPos.X);
            InkCanvas.SetTop(_TStartPos, _MapDatabase._TStartPos.Y);
            for (int i = 0; i < _MapDatabase._Layers.Count; i++)
            {
                MapDatabase.Layer _Layer      = _MapDatabase._Layers[i];
                InkCanvas         _InkCanvas1 = (InkCanvas)_CanvasList.Children[i];
                foreach (MapDatabase.Image _DImage in _Layer._Images)
                {
                    Image _Image = new Image();
                    if (!File.Exists(_DImage.Path))
                    {
                        Debugger.Break();
                    }

                    BitmapImage _BitmapImage = new BitmapImage(new Uri(_DImage.Path, UriKind.Relative));
                    double      a            = _BitmapImage.Width;
                    _Image.Source = _BitmapImage;

                    _Image.Width  = _DImage.Width;
                    _Image.Height = _DImage.Height;
                    InkCanvas.SetLeft(_Image, _DImage.X);
                    InkCanvas.SetTop(_Image, _DImage.Y);
                    _InkCanvas1.Children.Add(_Image);
                }
                foreach (MapDatabase.Polygon _Polygon in _Layer._Polygons)
                {
                    StylusPointCollection _StylusPointCollection = new StylusPointCollection();
                    foreach (Point _Point in _Polygon._Points)
                    {
                        StylusPoint _StylusPoint = new StylusPoint(_Point.X, _Point.Y);
                        _StylusPointCollection.Add(_StylusPoint);
                    }

                    CustomStroke _Stroke = new CustomStroke(_StylusPointCollection);
                    _Stroke.DrawingAttributes.Color = _Polygon._Color;
                    _InkCanvas1.Strokes.Add(_Stroke);
                }
            }
        }
Пример #9
0
        public override void Undo(CustomStrokeCollection strokes)
        {
            if (strokes.has(Id))
            {
                CustomStroke old = strokes.get(Id);
                if (old.isLocked())
                {
                    throw new Exception("Stroke is Locked");
                }

                strokes.Remove(strokes.get(Id));
                EditionSocket.RemoveStroke(Id);
            }
        }
Пример #10
0
        private void Canvas_StrokeErasing(object sender, InkCanvasStrokeErasingEventArgs e)
        {
            VueModele vueModele = ((VueModele)this.DataContext);

            //Empiler la modification
            if (e.Stroke is Savable && !((CustomStroke)e.Stroke).isLocked())
            {
                CustomStroke erasedStroke = (CustomStroke)e.Stroke;
                vueModele.editeur.Do(new DeleteStroke(erasedStroke.Id.ToString(), ((Savable)erasedStroke).toJson()));
                EditionSocket.RemoveStroke(erasedStroke.Id.ToString());
            }
            else if (((CustomStroke)e.Stroke).isLocked())
            {
                e.Cancel = true;
            }
        }
Пример #11
0
        public override void Undo(CustomStrokeCollection strokes)
        {
            if (strokes.has(Id))
            {
                CustomStroke old = strokes.get(Id);
                if (old.isLocked())
                {
                    throw new Exception("Stroke is Locked");
                }

                EditionSocket.EditStroke(SerializedStrokeBefore);

                CustomStroke updated  = SerializationHelper.stringToStroke(JObject.Parse(SerializedStrokeBefore), strokes);
                bool         selected = ((CustomStroke)old).isSelected();
                bool         editting = ((CustomStroke)old).isEditing();
                ((CustomStroke)old).stopEditing();
                strokes.Remove(strokes.get(Id));

                int newindex = strokes.ToList().FindIndex(stroke => ((CustomStroke)stroke).Index > updated.Index);

                try
                {
                    strokes.Insert(newindex, updated);
                }
                catch
                {
                    strokes.Add(updated);
                }

                if (selected)
                {
                    strokes.get(updated.Id.ToString()).Select();
                }
                if (editting)
                {
                    strokes.get(updated.Id.ToString()).startEditing();
                }

                if (updated is Anchorable)
                {
                    strokes.ToList().FindAll(stroke => stroke is BaseLine).ForEach(stroke => ((BaseLine)stroke).anchorableMoved((Anchorable)updated));
                }
            }
        }
        public void DrawTextInRectangle(object sender, RoutedEventArgs e)
        {
            StylusPointCollection pts = new StylusPointCollection();

            pts.Add(new StylusPoint(100, 100));

            pts.Add(new StylusPoint(100, 300));

            pts.Add(new StylusPoint(300, 300));

            pts.Add(new StylusPoint(300, 100));

            pts.Add(new StylusPoint(100, 100));

            CustomStroke st = new CustomStroke(pts);

            st.DrawingAttributes.Color = Colors.Red;
            inkCanvas1.Strokes.Add(st);
        }
Пример #13
0
        private void ReceiveDrawingInk(JObject data)
        {
            try
            {
                double?X1 = (double?)data.GetValue("startPosX");
                double?X2 = (double?)data.GetValue("endPosX");
                double?Y1 = (double?)data.GetValue("startPosY");
                double?Y2 = (double?)data.GetValue("endPosY");

                if (!(X1.HasValue && X2.HasValue && Y1.HasValue && Y2.HasValue))
                {
                    return;
                }

                StylusPointCollection coll = new StylusPointCollection();
                coll.Add(new StylusPoint(X1.Value, Y1.Value));
                coll.Add(new StylusPoint(X2.Value, Y2.Value));

                DrawingAttributes attr = new DrawingAttributes();
                attr.Color     = (Color)ColorConverter.ConvertFromString((string)data.GetValue("color"));
                attr.Height    = (double)data.GetValue("width");
                attr.Width     = attr.Height;
                attr.StylusTip = (string)data.GetValue("format") == "circle" ? StylusTip.Ellipse : StylusTip.Rectangle;

                CustomStroke str = new CustomStroke(coll, attr);
                str.uid = currentStrokeId;

                App.Current.Dispatcher.Invoke(delegate
                {
                    Traits.Add(str);
                });

                if ((bool)data.GetValue("isEnd"))
                {
                    MergeStrokes(attr);
                }
            }
            catch (Exception)
            {
                // fail silently
            }
        }
Пример #14
0
        public static void Post(CustomStroke customStroke)
        {
            var request = new RestRequest(Settings.API_VERSION + Settings.SHAPE_OBJECT_PATH, Method.POST);

            if (customStroke is ShapeStroke)
            {
                request.AddJsonBody(((ShapeStroke)customStroke).toJson());
            }
            else if (customStroke is BaseLine)
            {
                request.AddJsonBody(((BaseLine)customStroke).toJson());
            }
            ServerService.instance.server.ExecuteAsync(request, response =>
            {
                Application.Current.Dispatcher.Invoke(() =>
                {
                    if (response.StatusCode != HttpStatusCode.Created)
                    {
                        MessageBox.Show("Could not save the image", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                });
            });
        }
        // Quand une nouvelle nouvelle stroke a ete ajoute
        private void surfaceDessin_OnMouseUp(object sender, MouseButtonEventArgs e)
        {
            if ((DataContext as VueModele)?.OutilSelectionne == "crayon" && surfaceDessin.SelectedStrokes.Count > 0)
            {
                CustomStroke newStroke = (DataContext as VueModele).AddStrokeFromView(
                    (CustomStroke)surfaceDessin.SelectedStrokes[0]
                    );
                surfaceDessin.Select(new StrokeCollection {
                    newStroke
                });
                if (newStroke.GetType() != typeof(LinkStroke))
                {
                    Path path = new Path();
                    path.Data = new RectangleGeometry(newStroke.GetBounds());
                    surfaceDessin.Children.Add(path);
                    AdornerLayer myAdornerLayer = AdornerLayer.GetAdornerLayer(path);
                    myAdornerLayer.Add(new RotateAdorner(path, newStroke, surfaceDessin));
                    myAdornerLayer.Add(new AnchorPointAdorner(path, newStroke, surfaceDessin));
                    Adorner[] ad = myAdornerLayer.GetAdorners(path);
                    myAdornerLayer.Add(new EditionAdorner(path, newStroke, surfaceDessin));
                }
            }
            else
            {
                foreach (CustomStroke stroke in surfaceDessin.GetSelectedStrokes())
                {
                    if (stroke is LinkStroke)
                    {
                        surfaceDessin.modifyLinkStrokePath(stroke as LinkStroke, e.GetPosition(surfaceDessin));
                    }
                }
            }


            // Pour que les boutons soient de la bonne couleur
            (DataContext as VueModele)?.ChoisirOutil.Execute("lasso");
        }
Пример #16
0
        public override bool HitTest(Point point)
        {
            if (!this.strokes.has(this.ParentId))
            {
                return(false);
            }

            CustomStroke parent = this.strokes.get(this.ParentId);
            Point        thisDisplayedPosition;

            if (parent is ShapeStroke)
            {
                ShapeStroke shapeParent   = (ShapeStroke)parent;
                Matrix      rotationMatix = new Matrix();
                rotationMatix.RotateAt(shapeParent.Rotation, shapeParent.Center.X, shapeParent.Center.Y);
                thisDisplayedPosition = rotationMatix.Transform(this.StylusPoints[0].ToPoint());
            }
            else
            {
                thisDisplayedPosition = this.StylusPoints[0].ToPoint();
            }

            return(6 > Math.Sqrt(Math.Pow(point.X - thisDisplayedPosition.X, 2) + Math.Pow(point.Y - thisDisplayedPosition.Y, 2)));
        }
Пример #17
0
        private void Canvas_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            Point        point    = e.GetPosition((IInputElement)sender);
            CustomStroke scrolled = null;

            Canvas.Strokes.ToList().ForEach(stroke =>
            {
                CustomStroke customStroke = (CustomStroke)stroke;
                if (!customStroke.isSelected())
                {
                    return;
                }
                if (!customStroke.HitTest(point))
                {
                    return;
                }

                scrolled = customStroke;
            });

            /* UNCOMMENT TO ENABLE ROTATING */
            //if (scrolled is ShapeStroke)
            //    ((ShapeStroke)scrolled).Rotation = ((ShapeStroke)scrolled).Rotation += e.Delta / 8.0;
        }
Пример #18
0
        public static void Initialize(object o)
        {
            socket.On(Socket.EVENT_RECONNECT, () =>
            {
                if (canvasName != null)
                {
                    // Stocker le mot de passe? ADD
                    JoinCanvas(canvasName, "");
                }
            });

            #region canvas .On
            socket.On("createCanvasResponse", (data) =>
            {
                CreateCanvasResponse response = serializer.Deserialize <CreateCanvasResponse>((string)data);
                if (response.isCreated)
                {
                    canvasName = response.canvasName;
                    RefreshCanvases();
                }
                else
                {
                    Application.Current?.Dispatcher?.Invoke(new Action(() => { CanvasCreationFailed(); }), DispatcherPriority.Render);
                }
            });

            socket.On("canvasCreated", (data) =>
            {
                RefreshCanvases();
            });

            socket.On("updateCanvasPasswordResponse", (data) =>
            {
                UpdateCanvasPasswordResponse response = serializer.Deserialize <UpdateCanvasPasswordResponse>((string)data);
                if (response.isPasswordUpdated)
                {
                    RefreshCanvases();
                }
            });

            socket.On("canvasPasswordUpdated", (data) =>
            {
                LeaveCanvas();
                Application.Current?.Dispatcher?.Invoke(new Action(() => { BackToGallery(); }), DispatcherPriority.Render);
            });

            socket.On("accessCanvasResponse", (data) =>
            {
                AccessCanvasResponse response = serializer.Deserialize <AccessCanvasResponse>((string)data);
                if (response.isPasswordValid)
                {
                    canvasName = response.canvasName;
                }
                Application.Current?.Dispatcher?.Invoke(new Action(() => { JoinCanvasRoom(response); }), DispatcherPriority.Render);
            });

            socket.On("canvasSelected", (data) =>
            {
                EditGalleryData response = serializer.Deserialize <EditGalleryData>((string)data);
                if (!username.Equals((string)response.username) && response.canevasName.Equals(canvasName))
                {
                    isCanvasSizeRemotelyEditing = true;
                }
            });

            socket.On("canvasDeselected", (data) =>
            {
                EditGalleryData response = serializer.Deserialize <EditGalleryData>((string)data);
                if (!username.Equals((string)response.username) && response.canevasName.Equals(canvasName))
                {
                    isCanvasSizeRemotelyEditing = false;
                }
            });

            socket.On("canvasResized", (data) =>
            {
                ResizeCanevasData response = serializer.Deserialize <ResizeCanevasData>((string)data);
                if (username != null && !username.Equals((string)response.username))
                {
                    Application.Current?.Dispatcher?.Invoke(new Action(() => { OnResizeCanvas(response.dimensions); }), DispatcherPriority.Render);
                }
            });

            socket.On("getPublicCanvasResponse", (data) =>
            {
                PublicCanvases canvases = serializer.Deserialize <PublicCanvases>((string)data);

                ExtractCanvasesShapes(canvases.publicCanvas);

                try
                {
                    Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdatePublicCanvases(canvases); }), DispatcherPriority.Render);
                }
                catch { }
            });

            socket.On("getPrivateCanvasResponse", (data) =>
            {
                PrivateCanvases canvases = serializer.Deserialize <PrivateCanvases>((string)data);

                ExtractCanvasesShapes(canvases.privateCanvas);
                Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdatePrivateCanvases(canvases); }), DispatcherPriority.Render);
            });
            #endregion

            #region links .On
            socket.On("linkCreated", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                if (!username.Equals((string)response.username))
                {
                    LinkStroke linkStroke = createLinkStroke(response.links[0]);
                    linkStroke.owner      = response.username;
                    InkCanvasStrokeCollectedEventArgs eventArgs = new InkCanvasStrokeCollectedEventArgs(linkStroke);
                    Application.Current?.Dispatcher?.Invoke(new Action(() => { AddStroke(eventArgs); }), DispatcherPriority.ContextIdle);
                }
            });

            socket.On("linksDeleted", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                if (!username.Equals((string)response.username))
                {
                    StrokeCollection strokes = new StrokeCollection();
                    foreach (dynamic link in response.links)
                    {
                        strokes.Add(createLinkStroke(link));
                    }
                    Application.Current?.Dispatcher?.Invoke(new Action(() => { RemoveStrokes(strokes); }), DispatcherPriority.ContextIdle);
                }
            });

            socket.On("linksUpdated", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                if (!username.Equals((string)response.username))
                {
                    foreach (dynamic link in response.links)
                    {
                        InkCanvasStrokeCollectedEventArgs eventArgs = new InkCanvasStrokeCollectedEventArgs(createLinkStroke(link));
                        Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdateStroke(eventArgs); }), DispatcherPriority.Render);
                    }
                }
            });

            socket.On("linksSelected", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                if (!username.Equals((string)response.username))
                {
                    StrokeCollection strokes = new StrokeCollection();
                    foreach (dynamic link in response.links)
                    {
                        LinkStroke linkStroke = createLinkStroke(link);
                        strokes.Add(linkStroke);
                        if (!remoteSelectedStrokes.Contains(linkStroke.guid.ToString()))
                        {
                            remoteSelectedStrokes.Add(linkStroke.guid.ToString());
                        }
                        Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdateSelection(); }), DispatcherPriority.Render);
                    }
                }
            });

            socket.On("linksDeselected", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                if (!username.Equals((string)response.username))
                {
                    StrokeCollection strokes = new StrokeCollection();
                    foreach (dynamic link in response.links)
                    {
                        LinkStroke linkStroke = createLinkStroke(link);
                        strokes.Add(linkStroke);
                        if (remoteSelectedStrokes.Contains(linkStroke.guid.ToString()))
                        {
                            remoteSelectedStrokes.Remove(linkStroke.guid.ToString());
                        }
                        Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdateDeselection(); }), DispatcherPriority.Render);
                    }
                }
            });
            #endregion

            #region forms .On
            socket.On("formCreated", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                //Console.WriteLine("FORM CREATED: \n" + "position: " + response.forms[0].shapeStyle.coordinates.x + ", "
                //    + response.forms[0].shapeStyle.coordinates.y + "/n" + "size: " + response.forms[0].shapeStyle.width + ", "
                //    + response.forms[0].shapeStyle.height);
                if (!username.Equals((string)response.username))
                {
                    CustomStroke customStroke = createShapeStroke(response.forms[0]);
                    InkCanvasStrokeCollectedEventArgs eventArgs = new InkCanvasStrokeCollectedEventArgs(customStroke);
                    Application.Current?.Dispatcher?.Invoke(new Action(() => { AddStroke(eventArgs); }), DispatcherPriority.ContextIdle);
                }
            });

            socket.On("formsDeleted", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                if (!username.Equals((string)response.username))
                {
                    StrokeCollection strokes = new StrokeCollection();
                    foreach (dynamic shape in response.forms)
                    {
                        ShapeStroke shapeStroke = createShapeStroke(shape);
                        if (remoteSelectedStrokes.Contains(shapeStroke.guid.ToString()))
                        {
                            remoteSelectedStrokes.Remove(shapeStroke.guid.ToString());
                        }
                        strokes.Add(shapeStroke);
                    }
                    Application.Current?.Dispatcher?.Invoke(new Action(() => { RemoveStrokes(strokes); }), DispatcherPriority.ContextIdle);
                }
            });

            socket.On("formsUpdated", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                if (!username.Equals((string)response.username))
                {
                    foreach (dynamic shape in response.forms)
                    {
                        InkCanvasStrokeCollectedEventArgs eventArgs = new InkCanvasStrokeCollectedEventArgs(createShapeStroke(shape));
                        Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdateStroke(eventArgs); }), DispatcherPriority.Render);
                    }
                }
            });

            socket.On("formsSelected", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                if (!username.Equals((string)response.username))
                {
                    StrokeCollection strokes = new StrokeCollection();
                    foreach (dynamic shape in response.forms)
                    {
                        ShapeStroke stroke = createShapeStroke(shape);
                        strokes.Add(stroke);
                        if (!remoteSelectedStrokes.Contains(stroke.guid.ToString()))
                        {
                            remoteSelectedStrokes.Add(stroke.guid.ToString());
                        }
                        Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdateSelection(); }), DispatcherPriority.Render);
                    }
                }
            });

            socket.On("formsDeselected", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                if (!username.Equals((string)response.username))
                {
                    StrokeCollection strokes = new StrokeCollection();
                    foreach (dynamic shape in response.forms)
                    {
                        ShapeStroke stroke = createShapeStroke(shape);
                        strokes.Add(stroke);
                        if (remoteSelectedStrokes.Contains(stroke.guid.ToString()))
                        {
                            remoteSelectedStrokes.Remove(stroke.guid.ToString());
                        }
                        Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdateDeselection(); }), DispatcherPriority.Render);
                    }
                }
            });
            #endregion

            socket.On("selectedForms", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                foreach (string id in response.selectedForms)
                {
                    if (!remoteSelectedStrokes.Contains(id))
                    {
                        remoteSelectedStrokes.Add(id);
                    }
                }
                Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdateDeselection(); }), DispatcherPriority.Render);
            });

            socket.On("selectedLinks", (data) =>
            {
                dynamic response = JObject.Parse((string)data);
                foreach (string id in response.selectedLinks)
                {
                    if (!remoteSelectedStrokes.Contains(id))
                    {
                        remoteSelectedStrokes.Add(id);
                    }
                }
                Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdateDeselection(); }), DispatcherPriority.Render);
            });

            socket.On("canvasSaved", (data) =>
            {
                EditCanevasData response = serializer.Deserialize <EditCanevasData>((string)data);
                RefreshCanvases();
                saving = false;
            });

            socket.On("getCanvasResponse", (data) =>
            {
                Templates.Canvas canvas = serializer.Deserialize <Templates.Canvas>((string)data);
                canvasName    = canvas.name;
                currentCanvas = canvas;
                Application.Current?.Dispatcher?.Invoke(new Action(() => { OnResizeCanvas(canvas.dimensions); }), DispatcherPriority.ContextIdle);
                localSelectedStrokes             = new List <string>();
                localAddedStrokes                = new List <string>();
                EditGalleryData editGallerysData = new EditGalleryData(username, canvasName, "");

                foreach (Link link in canvas.links)
                {
                    LinkStroke linkStroke = LinkStrokeFromLink(link);
                    InkCanvasStrokeCollectedEventArgs eventArgs = new InkCanvasStrokeCollectedEventArgs(linkStroke);
                    Application.Current?.Dispatcher?.Invoke(new Action(() => { AddStroke(eventArgs); }), DispatcherPriority.ContextIdle);
                }

                List <BasicShape> basicShapes = ExtractShapesFromCanvas(canvas);
                foreach (BasicShape shape in basicShapes)
                {
                    ShapeStroke shapeStroke = ShapeStrokeFromShape(shape);
                    InkCanvasStrokeCollectedEventArgs eventArgs = new InkCanvasStrokeCollectedEventArgs(shapeStroke);
                    Application.Current?.Dispatcher?.Invoke(new Action(() => { AddStroke(eventArgs); }), DispatcherPriority.ContextIdle);
                }

                socket.Emit("getSelectedForms", serializer.Serialize(editGallerysData));
                socket.Emit("getSelectedLinks", serializer.Serialize(editGallerysData));

                Application.Current?.Dispatcher?.Invoke(new Action(() => { RefreshChildren(); }), DispatcherPriority.ContextIdle);
            });

            socket.On("canvasReinitialized", (data) =>
            {
                localAddedStrokes     = new List <string>();
                localSelectedStrokes  = new List <string>();
                remoteSelectedStrokes = new List <string>();
                Application.Current?.Dispatcher?.Invoke(new Action(() => { RemoteReset(); }), DispatcherPriority.Render);
            });

            socket.On("getCanvasLogHistoryResponse", (data) =>
            {
                HistoryData[] historyData = serializer.Deserialize <HistoryData[]>((string)data);
                History history           = new History(historyData);

                Application.Current?.Dispatcher?.Invoke(new Action(() => { UpdateHistory(history); }), DispatcherPriority.Render);
            });

            socket.On("disconnect", (data) =>
            {
                // Application.Current?.Dispatcher?.Invoke(new Action(() => { BackToGallery(); }), DispatcherPriority.ContextIdle);
            });

            RefreshCanvases();
        }
Пример #19
0
        void InkCanvasKeyDown(object sender, KeyEventArgs e)
        {
            oldkey = e.Key;
            for (int i = 0; i < 5; i++)
                if (Keyboard.IsKeyDown(Key.D1 + i))
                    SelectCanvas(i);
            //D = (int)e.Key - 83;
            //if (D >= 0 && D <= 5)
            //    SelectCanvas(D);

            if (Keyboard.IsKeyDown(Key.LeftCtrl) && Keyboard.IsKeyDown(Key.Z))
            {
                if (_Stroke != null)
                {
                    if (_curentPoint > 0)
                    {
                        _Stroke.StylusPoints.RemoveAt(_curentPoint);
                        _curentPoint--;
                    }
                    else
                    {
                        _InkCanvas.Strokes.Remove(_Stroke);
                        _Stroke = null;
                    }
                }
            }

            if (e.Key == Key.Q)
            {
                SetMode(InkCanvasEditingMode.Select, CustomMode.select);
            }
            if (e.Key == Key.W)
            {
                SetMode(InkCanvasEditingMode.None, CustomMode.polygon);
            }
            if (e.Key == Key.E)
            {
                SetMode(InkCanvasEditingMode.EraseByPoint, CustomMode.erase);
            }

            if (e.Key == Key.Add || e.Key == Key.Subtract)
            {
                double _ScaleFactor = e.Key == Key.Add ? 1.2 : .8;
                _Scale *= _ScaleFactor;
                _ScaleText.Text = _Scale.ToString();
                foreach (InkCanvas _InkCanvas in _CanvasList.Children)
                {
                    foreach (Stroke _Stroke in _InkCanvas.Strokes)
                        for (int i = 0; i < _Stroke.StylusPoints.Count; i++)
                        {
                            StylusPoint _StylusPoint = _Stroke.StylusPoints[i];
                            _Stroke.StylusPoints[i] = new StylusPoint(_StylusPoint.X * _ScaleFactor, _StylusPoint.Y * _ScaleFactor);
                        }
                    foreach (FrameworkElement _Image in _InkCanvas.Children)
                    {
                        InkCanvas.SetLeft(_Image, InkCanvas.GetLeft(_Image) * _ScaleFactor);
                        InkCanvas.SetTop(_Image, InkCanvas.GetTop(_Image) * _ScaleFactor);
                        _Image.Width = _Image.ActualWidth * _ScaleFactor;
                        _Image.Height = _Image.ActualHeight * _ScaleFactor;
                    }
                }
            }
            if (e.Key == Key.C)
            {
                SelectColor();
            }
            if (e.Key == Key.PageUp)
            {
                StrokeCollection _StrokeCollection = _InkCanvas.GetSelectedStrokes();
                foreach (Stroke _Stroke in _StrokeCollection)
                {
                    _InkCanvas.Strokes.Remove(_Stroke);
                    _InkCanvas.Strokes.Add(_Stroke);
                }
            }
            if (e.Key == Key.PageDown)
            {
                StrokeCollection _StrokeCollection = _InkCanvas.GetSelectedStrokes();
                foreach (Stroke _Stroke in _StrokeCollection)
                {
                    _InkCanvas.Strokes.Remove(_Stroke);
                    _InkCanvas.Strokes.Insert(0, _Stroke);
                }
            }
            if (Keyboard.IsKeyDown(Key.C) && Keyboard.IsKeyDown(Key.LeftCtrl))
            {
                _InkCanvas.CopySelection();
            }
            //if (Keyboard.IsKeyDown(Key.X) && Keyboard.IsKeyDown(Key.LeftCtrl))
            //{
            //    _InkCanvas.CutSelection();
            //}
            if (Keyboard.IsKeyDown(Key.V) && Keyboard.IsKeyDown(Key.LeftCtrl))
            {
                _InkCanvas.Paste();
            }
            if (e.Key == Key.B)
            {
                if (_PolygonsCanvas.Children.Count > 0)
                    _PolygonsCanvas.Children.Clear();
                else
                    foreach (InkCanvas _InkCanvas1 in _CanvasList.Children)
                        foreach (Stroke _Stroke in _InkCanvas1.Strokes)
                        {
                            if (_Stroke.StylusPoints.Last() == _Stroke.StylusPoints.First())
                            {
                                Polygon _Polygon = new Polygon();
                                foreach (StylusPoint _Point in _Stroke.StylusPoints)
                                {
                                    _Polygon.Points.Add(new Point(_Point.X, _Point.Y));
                                }
                                _Polygon.Fill = new SolidColorBrush(_Stroke.DrawingAttributes.Color);
                                _PolygonsCanvas.Children.Add(_Polygon);
                            }
                        }
            }
        }
Пример #20
0
        void InkCanvas_MouseDown(object sender, MouseButtonEventArgs e)
        {
            Point _pos = e.GetPosition(_InkCanvas);
            if (e.RightButton == MouseButtonState.Pressed)
            {
                SetStroke();
                if (_CurCustomMode == CustomMode.polygon)
                {
                    foreach (InkCanvas _InkCanvas1 in _CanvasList.Children)
                        foreach (CustomStroke _Stroke1 in _InkCanvas1.Strokes)
                            for (int i = 0; i < _Stroke1.StylusPoints.Count; i++)
                            {
                                StylusPoint _StylusPoint = _Stroke1.StylusPoints[i];
                                double l = ((Vector)(Convert(_StylusPoint) - _pos)).Length;
                                if (l < 10)
                                {
                                    _curentPoint = i;
                                    _Stroke = _Stroke1;
                                }
                            }
                }
            }
            if (e.LeftButton == MouseButtonState.Pressed)
            {
                if (_CurCustomMode == CustomMode.polygon)
                {

                    //if (Keyboard.IsKeyDown(Key.LeftCtrl))
                    {
                        foreach (InkCanvas _InkCanvas1 in _CanvasList.Children)
                            foreach (CustomStroke _Stroke1 in _InkCanvas1.Strokes)
                                for (int i = 0; i < _Stroke1.StylusPoints.Count; i++)
                                {
                                    StylusPoint _StylusPoint = _Stroke1.StylusPoints[i];
                                    double l = ((Vector)(Convert(_StylusPoint) - _pos)).Length;
                                    if (l < 5)
                                    {
                                        _pos = Convert(_StylusPoint);
                                    }
                                }
                    }

                    if (_Stroke == null)
                    {
                        StylusPointCollection _StylusPointCollection = new StylusPointCollection();
                        Point _Point = _pos;
                        _StylusPointCollection.Add(new StylusPoint(_Point.X, _Point.Y));
                        _Stroke = new CustomStroke(_StylusPointCollection);
                        _InkCanvas.Strokes.Add(_Stroke);

                        _curentPoint = 0;

                    }
                    else
                    {
                        StylusPoint _StylusPoint = new StylusPoint(_pos.X, _pos.Y);
                        _curentPoint++;
                        _Stroke.StylusPoints.Insert(_curentPoint, _StylusPoint);
                    }
                }
            }
        }
Пример #21
0
        //Loaddata
        private void OpenFile(string _FilePath)
        {
            if (!File.Exists(_FilePath)) { Trace.WriteLine("file not exists " + _FilePath); return; }
            byte[] _Buffer = File.ReadAllBytes(_FilePath);
            MemoryStream _MemoryStream = new MemoryStream(_Buffer);
            _MapDatabase = (MapDatabase)_XmlSerializer.Deserialize(_MemoryStream);

            _InkCanvas.Strokes.Clear();

            InkCanvas.SetLeft(_CStartPos, _MapDatabase._CStartPos.X);
            InkCanvas.SetTop(_CStartPos, _MapDatabase._CStartPos.Y);
            InkCanvas.SetLeft(_TStartPos, _MapDatabase._TStartPos.X);
            InkCanvas.SetTop(_TStartPos, _MapDatabase._TStartPos.Y);
            for (int i = 0; i < _MapDatabase._Layers.Count; i++)
            {
                MapDatabase.Layer _Layer = _MapDatabase._Layers[i];
                InkCanvas _InkCanvas1 = (InkCanvas)_CanvasList.Children[i];
                foreach (MapDatabase.Image _DImage in _Layer._Images)
                {
                    Image _Image = new Image();
                    if (!File.Exists(_DImage.Path)) Debugger.Break();

                    BitmapImage _BitmapImage = new BitmapImage(new Uri(_DImage.Path, UriKind.Relative));
                    double a = _BitmapImage.Width;
                    _Image.Source = _BitmapImage;

                    _Image.Width = _DImage.Width;
                    _Image.Height = _DImage.Height;
                    InkCanvas.SetLeft(_Image, _DImage.X);
                    InkCanvas.SetTop(_Image, _DImage.Y);
                    _InkCanvas1.Children.Add(_Image);
                }
                foreach (MapDatabase.Polygon _Polygon in _Layer._Polygons)
                {
                    StylusPointCollection _StylusPointCollection = new StylusPointCollection();
                    foreach (Point _Point in _Polygon._Points)
                    {
                        StylusPoint _StylusPoint = new StylusPoint(_Point.X, _Point.Y);
                        _StylusPointCollection.Add(_StylusPoint);
                    }

                    CustomStroke _Stroke = new CustomStroke(_StylusPointCollection);
                    _Stroke.DrawingAttributes.Color = _Polygon._Color;
                    _InkCanvas1.Strokes.Add(_Stroke);
                }
            }
        }
Пример #22
0
 private void SetStroke()
 {
     if (_Stroke != null)
     {
         InkCanvas_StrokeCollected(_InkCanvas, new InkCanvasStrokeCollectedEventArgs(_Stroke));
         _Stroke = null;
     }
 }
Пример #23
0
        void InkCanvas_MouseDown(object sender, MouseButtonEventArgs e)
        {
            Point _pos = e.GetPosition(_InkCanvas);

            if (e.RightButton == MouseButtonState.Pressed)
            {
                SetStroke();
                if (_CurCustomMode == CustomMode.polygon)
                {
                    foreach (InkCanvas _InkCanvas1 in _CanvasList.Children)
                    {
                        foreach (CustomStroke _Stroke1 in _InkCanvas1.Strokes)
                        {
                            for (int i = 0; i < _Stroke1.StylusPoints.Count; i++)
                            {
                                StylusPoint _StylusPoint = _Stroke1.StylusPoints[i];
                                double      l            = ((Vector)(Convert(_StylusPoint) - _pos)).Length;
                                if (l < 10)
                                {
                                    _curentPoint = i;
                                    _Stroke      = _Stroke1;
                                }
                            }
                        }
                    }
                }
            }
            if (e.LeftButton == MouseButtonState.Pressed)
            {
                if (_CurCustomMode == CustomMode.polygon)
                {
                    //if (Keyboard.IsKeyDown(Key.LeftCtrl))
                    {
                        foreach (InkCanvas _InkCanvas1 in _CanvasList.Children)
                        {
                            foreach (CustomStroke _Stroke1 in _InkCanvas1.Strokes)
                            {
                                for (int i = 0; i < _Stroke1.StylusPoints.Count; i++)
                                {
                                    StylusPoint _StylusPoint = _Stroke1.StylusPoints[i];
                                    double      l            = ((Vector)(Convert(_StylusPoint) - _pos)).Length;
                                    if (l < 5)
                                    {
                                        _pos = Convert(_StylusPoint);
                                    }
                                }
                            }
                        }
                    }

                    if (_Stroke == null)
                    {
                        StylusPointCollection _StylusPointCollection = new StylusPointCollection();
                        Point _Point = _pos;
                        _StylusPointCollection.Add(new StylusPoint(_Point.X, _Point.Y));
                        _Stroke = new CustomStroke(_StylusPointCollection);
                        _InkCanvas.Strokes.Add(_Stroke);

                        _curentPoint = 0;
                    }
                    else
                    {
                        StylusPoint _StylusPoint = new StylusPoint(_pos.X, _pos.Y);
                        _curentPoint++;
                        _Stroke.StylusPoints.Insert(_curentPoint, _StylusPoint);
                    }
                }
            }
        }
Пример #24
0
 internal CustomStroke AddStrokeFromView(CustomStroke selectedStroke /*StylusPoint firstPoint, StrokeTypes strokeType*/)
 {
     return(editeur.AddStrokeFromView(selectedStroke));
 }