Esempio n. 1
0
        protected override void OnCommit()
        {
            if (CanvasContext.ActiveLayer == null)
            {
                throw new InvalidOperationException();
            }

            if (_copiedDrawObjects.Count == 0)
            {
                return;
            }

            var commitedDrawObjects = _copiedDrawObjects.ToArray();
            var layer = CanvasContext.ActiveLayer;

            layer.AddDrawObjects(commitedDrawObjects);

            //呈递事务;
            var transaction = new StandardEditTransaction(
                () => {
                layer.RemoveDrawObjects(commitedDrawObjects);
            },
                () => {
                layer.AddDrawObjects(commitedDrawObjects);
            }
                );

            CommitTransaction(transaction);
        }
Esempio n. 2
0
        public static void RemoveDrawObjects(this ICanvasDataContext canvasDataContext, ICollection <DrawObject> drawObjects)
        {
            if (drawObjects == null)
            {
                throw new ArgumentNullException(nameof(drawObjects));
            }

            if (drawObjects.Count == 0)
            {
                return;
            }

            //激发即将移除事件;
            var removingArgs = new CanvasDrawObjectsRemovingEventArgs(drawObjects, canvasDataContext);

            CommonEventHelper.Publish <CanvasDrawObjectsRemovingEvent, CanvasDrawObjectsRemovingEventArgs>(removingArgs);
            CommonEventHelper.PublishEventToHandlers <ICanvasDrawObjectsRemovingEventHandler, CanvasDrawObjectsRemovingEventArgs>(removingArgs);
            //若指示取消或集合为空,则不继续执行;
            if (removingArgs.Cancel || removingArgs.RemovingDrawObjects.Count == 0)
            {
                return;
            }

            var removingGroups = removingArgs.RemovingDrawObjects.
                                 GroupBy(p => p.Parent as CanvasLayer).Where(p => p.Key != null).ToArray();

            void RemoveDrawObjects()
            {
                try {
                    foreach (var tuple in removingGroups)
                    {
                        tuple.Key.RemoveDrawObjects(tuple);
                    }
                }
                catch (Exception ex) {
                    LoggerService.WriteException(ex);
                    MsgBoxService.ShowError(ex.Message);
                }
            }

            void AddDrawObjects()
            {
                try {
                    foreach (var tuple in removingGroups)
                    {
                        tuple.Key.AddDrawObjects(tuple);
                    }
                }
                catch (Exception ex) {
                    LoggerService.WriteException(ex);
                    MsgBoxService.ShowError(ex.Message);
                }
            }

            RemoveDrawObjects();

            var action = new StandardEditTransaction(AddDrawObjects, RemoveDrawObjects);

            canvasDataContext.CommitTransaction(action);
        }
Esempio n. 3
0
        protected override void OnCommit()
        {
            if (_createdDrawObjects.Count == 0 && _originReplacedDrawObjects.Count == 0)
            {
                return;
            }

            var activeLayer = CanvasContext.ActiveLayer;

            if (activeLayer == null)
            {
                return;
            }

            //还原并移除被裁剪的绘制对象原件;
            _originReplacedDrawObjects.ForEach(p => p.IsVisible = true);
            activeLayer.RemoveDrawObjects(_originReplacedDrawObjects);

            ///应用裁剪后的绘制对象,即<see cref="_createdDrawObjects"/>,将其加入活跃图层中;
            var copiedCreatedDrawObjects        = _createdDrawObjects.ToArray();
            var copiedOriginReplacedDrawObjects = _originReplacedDrawObjects.ToArray();

            _createdDrawObjects.Clear();
            _originReplacedDrawObjects.Clear();

            activeLayer.AddDrawObjects(copiedCreatedDrawObjects);

            var transaction = new StandardEditTransaction(
                () => {
                try {
                    activeLayer.RemoveDrawObjects(copiedCreatedDrawObjects);
                    activeLayer.AddDrawObjects(copiedOriginReplacedDrawObjects);
                }
                catch (Exception ex) {
                    RaiseErrorOccurred(ex);
                    //CommandOutputService.Current.WriteLine(ex.Message);
#if DEBUG
                    throw;
#endif
                }
            },
                () => {
                try {
                    activeLayer.AddDrawObjects(copiedCreatedDrawObjects);
                    activeLayer.RemoveDrawObjects(copiedOriginReplacedDrawObjects);
                }
                catch (Exception ex) {
                    RaiseErrorOccurred(ex);
                    //CommandOutputService.Current.WriteLine(ex.Message);
#if DEBUG
                    throw;
#endif
                }
            }
                );

            CommitTransaction(transaction);
        }
Esempio n. 4
0
        public static void AddDrawObjects(this ICanvasDataContext canvasDataContext, ICollection <DrawObject> drawObjects)
        {
            if (drawObjects == null)
            {
                throw new ArgumentNullException(nameof(drawObjects));
            }

            if (drawObjects.Count == 0)
            {
                return;
            }

            var activeLayer = canvasDataContext.ActiveLayer;

            if (activeLayer == null)
            {
                return;
                //throw new InvalidOperationException(LanguageService.FindResourceString(Exception_ActiveLayerCannotBeNull));
            }

            void AddDrawObjects()
            {
                activeLayer.AddDrawObjects(drawObjects);
            };

            void RemoveDrawObjects()
            {
                activeLayer.RemoveDrawObjects(drawObjects);
            }

            AddDrawObjects();

            var transaction = new StandardEditTransaction(RemoveDrawObjects, AddDrawObjects);

            canvasDataContext.CommitTransaction(transaction);
        }
        /// <summary>
        /// 呈递修改的默认实现,本方法将呈递撤销栈中的修改操作,并清空撤销/重做栈;
        /// </summary>
        /// <param name="canvasContext"></param>
        protected override void OnCommit()
        {
            if (CanvasContext == null)
            {
                return;
            }

            //若撤销栈为空,则不进行呈递修改操作;
            if (UndoDrawObjects.Count == 0)
            {
                return;
            }

            if (CanvasContext.ActiveLayer == null)
            {
                return;
            }

            var commitParams = new UniqueTypeEditToolCommitParams(new List <DrawObject>(UndoDrawObjects.ToArray()))
            {
                AppliedLayer = CanvasContext.ActiveLayer
            };

            OnCommitParams(commitParams);

            if (commitParams.Cancel)
            {
                return;
            }

            if (commitParams.AppliedLayer == null)
            {
                return;
            }

            if (commitParams.AddedDrawObjects.Count == 0)
            {
                return;
            }

            //将撤销栈拷贝后呈递事务;
            var addedDrawObjects = commitParams.AddedDrawObjects.ToArray();
            var appliedLayer     = commitParams.AppliedLayer;

            appliedLayer.AddDrawObjects(addedDrawObjects);

            var transAction = new StandardEditTransaction(
                () => {
                appliedLayer.RemoveDrawObjects(addedDrawObjects);
            },
                () => {
                appliedLayer.AddDrawObjects(addedDrawObjects);
            }
                );

            CommitTransaction(transAction);

            //清除撤销/撤销栈;
            UndoDrawObjects.Clear();
            RedoDrawObjects.Clear();
        }