public void CanvasMouseBtnRDown(MouseEventArgs e)
        {
            if (!IsAnimationMode)
            {
                var itemsControl = e.Source as ItemsControl;
                _mousePosition = new Point(e.GetPosition(itemsControl).X, e.GetPosition(itemsControl).Y); //get mousePos


                //Find all images and bones  that are below the mousepos
                var count = ViewportCollection.Count(item => ((item is Texture2D) && (item as Texture2D).IsMouseOver) 
                    || (item is Bone && (item as Bone).IsMouseOver));

                if (count == 0)
                {
                    foreach (var obj in ViewportCollection)
                    {
                        if (obj is Texture2D) (obj as Texture2D).Selected = false;
                        else if (obj is Bone) (obj as Bone).Selected = false;
                    }
                    UpdateSelectedItem();
                }
                if (_boneDrawn != null)
                {
                    ViewportCollection.Remove(_boneDrawn);
                    _boneDrawn = null;
                }
            }
        }
Beispiel #2
0
 public Bone(Bone bone)
 {
     if (bone != null)
     {
         CenterPointX = bone.CenterPointX;
         CenterPointY = bone.CenterPointY;
         EndPointX = bone.EndPointX;
         EndPointY = bone.EndPointY;
         PosX = bone.PosX;
         PosY = bone.PosY;
         Name = bone.Name;
         Zindex = bone.Zindex;
         BoneShape = new Polygon
         {
             Stroke = new SolidColorBrush() {Color = Colors.Black},
             StrokeThickness = 2
         };
         Selected = bone.Selected;
         ScaleX = bone.ScaleX;
         ScaleY = bone.ScaleY;
         IsMouseOver = bone.IsMouseOver;
         ChildCollection = new ObservableCollection<object>();
         ChildCollection.CollectionChanged += OnChildCollectionChanged;
         foreach (var child in bone.ChildCollection)
         {
             if (child is Texture2D)
                 ChildCollection.Add(new Texture2D(child as Texture2D));
             else
                 ChildCollection.Add(new Bone(child as Bone));
         }
         if (bone.BoneShape != null) BoneShape.Points = bone.BoneShape.Points;
         Rotation = bone.Rotation;
     }
     else
     {
         //MessageBox.Show("An error occured!");
     }
 }
        public void CanvasMouseBtnLDown(MouseEventArgs e)
        {
            var itemsControl = e.Source as ItemsControl;
            _mousePosition = new Point(e.GetPosition(itemsControl).X, e.GetPosition(itemsControl).Y); //get mousePos
            if (itemsControl?.Items.Count > 0 && !IsDrawBonesMode && !IsAnimationMode)
            {
                //Filter out  images and bones that the cursor overlaps
                var texlist = new List<Texture2D>();
                var bonelist = new List<Bone>();
                try
                {
                    texlist = ViewportCollection.OfType<Texture2D>().ToList();
                    bonelist = ViewportCollection.OfType<Bone>().ToList();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
                

                var texOverlapList = texlist.Where(item => item.IsMouseOver).ToList();
                var boneOverlapList = bonelist.Where(item => item.IsMouseOver).ToList();
                if (texOverlapList.Count > 0 || boneOverlapList.Count > 0)
                {
                    Texture2D tex = null;
                    Bone bone = null;

                    if (texOverlapList.Count >= 1 ) tex = texOverlapList.Aggregate((i1, i2) => i1.Zindex > i2.Zindex ? i1 : i2);
                    if (boneOverlapList.Count >= 1) bone = boneOverlapList.Aggregate((i1, i2) => i1.Zindex > i2.Zindex ? i1 : i2);

                    if (bone != null)
                    {
                        //Set Everything else as not selected
                        foreach (var obj in ViewportCollection)
                        {
                            if (obj is Texture2D) ((Texture2D)obj).Selected = false;
                            else if (obj is Bone) ((Bone)obj).Selected = false;
                        }
                        Cursor = Cursors.SizeAll;
                        bone.Selected = true;
                        DraggedObject = bone;
                        _objPreTranslated = new Bone(bone);
                    }
                    else if (tex != null)
                    {
                        //check if cursor is in scale region
                        if (_mousePosition.X > (tex.PosX + tex.Width * tex.ScaleX) - _scaleOffsetArea &&
                            _mousePosition.X < (tex.PosX + tex.Width * tex.ScaleX) + _scaleOffsetArea &&
                            _mousePosition.Y > (tex.PosY + tex.Height * tex.ScaleY) - _scaleOffsetArea &&
                            _mousePosition.Y < (tex.PosY + tex.Height * tex.ScaleY) + _scaleOffsetArea)
                        {
                            ScaledTexture = tex;
                            _objPreTranslated = new Texture2D(tex);
                            Cursor = Cursors.SizeNWSE;
                        }
                        else //cursor was inside image 
                        {
                            //Set Everything else as not selected
                            foreach (var obj in itemsControl.Items)
                            {
                                if (obj is Texture2D) ((Texture2D)obj).Selected = false;
                                else if (obj is Bone) ((Bone)obj).Selected = false;
                            }
                            Cursor = Cursors.SizeAll;
                            tex.Selected = true;
                            DraggedObject = tex;
                            _objPreTranslated = new Texture2D(tex);
                        }
                    }
                }
                else //Cursor is clicking on empty canvas 
                {
                    //check if a bone or texture is selected if so it will be rotated in the mousemove
                    foreach (var texture in texlist) 
                    {
                        if (texture.Selected) 
                        {
                            RotatedObject = texture;
                            _objPreTranslated = new Texture2D(texture);
                        }
                    }
                    if (RotatedObject == null)
                    {
                        foreach (var bone in bonelist)
                        {
                            if (bone.Selected)
                            {
                                RotatedObject = bone;
                                _objPreTranslated = new Bone(bone);
                                break;
                            }
                        }
                    }
                }
            }
            else if(IsDrawBonesMode && !IsAnimationMode)
            {
                if (_boneDrawn == null)
                {
                    _boneDrawn = new Bone(_mousePosition.X,_mousePosition.Y, _mousePosition.X, _mousePosition.Y, string.Empty, 1.0,1.0) {Selected = true};
                    ViewportCollection.Add(_boneDrawn);
                }
                else
                {
                    //On second left click we are done drawing the bone
                    //Add Undo Action
                    var bone = _boneDrawn; //make a copy of the ref
                    AddUndoAction(new UnRedoPair(() => 
                    UndoDrop(new List<object>() { bone }), 
                    () => { _clearRedoStack = false; RedoDrop(new List<object>() { bone }); }));

                    _boneDrawn.Selected = false;
                    _boneDrawn = null;
                }

            }
            UpdateSelectedItem();
        }
        private void LBoxRightClickReset(object obj)
        {
            if (obj is Texture2D && !IsAnimationMode)
            {
                var tex = obj as Texture2D;
                var undoTex = new Texture2D(tex);
                tex.PosX = 0;
                tex.PosY = 0;
                tex.ScaleX = 1;
                tex.ScaleY = 1;
                tex.Rotation = 0;

                 AddUndoAction(new UnRedoPair(() =>
                 {
                     tex.PosX = undoTex.PosX;
                     tex.PosY = undoTex.PosY; 
                    tex.ScaleX = undoTex.ScaleX;
                    tex.ScaleY = undoTex.ScaleY;
                    tex.Rotation = undoTex.Rotation;
                 }, () => 
                 { _clearRedoStack = false; LBoxRightClickReset(obj); }));
            }
            else if (obj is Bone && !IsAnimationMode)
            {
                var bone = obj as Bone;
                var undoBone = new Bone(bone);
                bone.Selected = false;
                bone.Rotation = 0;
                bone.ScaleX = 1;
                bone.ScaleY = 1;

                AddUndoAction(new UnRedoPair(() =>
                {
                    bone.Selected = undoBone.Selected;
                    bone.Rotation = undoBone.Rotation;
                    bone.ScaleX = undoBone.ScaleX;
                    bone.ScaleY = undoBone.ScaleY;
                }, () => { _clearRedoStack = false; LBoxRightClickReset(obj); }));
            }
            UpdateSelectedItem();
        }
        private void LBoxRightClickAddBone(object obj)
        {

            if (!IsAnimationMode)
            {
                if (obj is Texture2D)
                {
                    var tex = obj as Texture2D;

                    var bone = new Bone(tex.PosX + tex.CenterPointX, tex.PosY + tex.CenterPointY, tex.PosX, tex.PosY, $"{Path.GetFileNameWithoutExtension(tex.Name)}", tex.ScaleX, tex.ScaleY);
                    bone.Selected = false;
                    ViewportCollection.Remove(tex);
                    ViewportCollection.Add(bone);
                    bone.ChildCollection.Add(tex);


                    AddUndoAction(new UnRedoPair(() => UndoDrop(new List<object>() { bone }),
                        (() => { _clearRedoStack = false; RedoDrop(new List<object>() { bone }); })));

                }
                else if (obj is Bone)
                {
                    var bone = obj as Bone;
                    Vector oldBoneVec = Vector.Subtract(new Vector(bone.EndPointX, bone.EndPointY), new Vector(bone.CenterPointX, bone.CenterPointY));
                    oldBoneVec = Vector.Multiply(oldBoneVec, 2);
                    oldBoneVec = Vector.Add(oldBoneVec, new Vector(bone.CenterPointX, bone.CenterPointY));
                    
                    var newBone = new Bone(bone.EndPointX, bone.EndPointY, oldBoneVec.X, oldBoneVec.Y, string.Empty, bone.ScaleX, bone.ScaleY);
                    newBone.PosX = bone.PosX;
                    newBone.PosY = bone.PosY;
                    newBone.Selected = false;
                    bone.ChildCollection.Add(newBone);

                    AddUndoAction(new UnRedoPair(() => UndoDrop(new List<object>() { newBone }),
                        (() => { _clearRedoStack = false; RedoDrop(new List<object>() { newBone }); })));
                }
            }
            UpdateSelectedItem();
        }
        public void InputGrid()
        {
            var undoObj = SelectedItem; //Make Ref of SelectedItem for undo
            if (_objPreTranslatedGrid is Texture2D)
            {
                var sTex = new Texture2D(SelectedItem as Texture2D);
                var sOrigTex = new Texture2D(_objPreTranslatedGrid as Texture2D);

                if (sTex.PosX != sOrigTex.PosX || sTex.PosY != sOrigTex.PosY || sTex.ScaleX != sOrigTex.ScaleX ||
                    sTex.ScaleY != sOrigTex.ScaleY || sTex.Rotation != sOrigTex.Rotation)
                {
                    AddUndoAction(new UnRedoPair(() =>
                    { Translate(undoObj, sOrigTex.PosX, sOrigTex.PosY, sOrigTex.ScaleX, sOrigTex.ScaleY, sOrigTex.Rotation, true); },
                    () => { Translate(undoObj, sTex.PosX, sTex.PosY, sTex.ScaleX, sTex.ScaleY, sTex.Rotation, false); }));
                }
            }
            else if (_objPreTranslatedGrid is Bone)
            {
                var sBone = new Bone(SelectedItem as Bone);
                var sOrigBone = new Bone(_objPreTranslatedGrid as Bone);

                if (sBone.PosX != sOrigBone.PosX || sBone.PosY != sOrigBone.PosY || sBone.ScaleX != sOrigBone.ScaleX ||
                    sBone.ScaleY != sOrigBone.ScaleY || sBone.Rotation != sOrigBone.Rotation)
                {
                    AddUndoAction(new UnRedoPair(() =>
                    { Translate(undoObj, sOrigBone.PosX, sOrigBone.PosY, sOrigBone.ScaleX, sOrigBone.ScaleY, sOrigBone.Rotation, true); },
                    () => { Translate(undoObj, sBone.PosX, sBone.PosY, sBone.ScaleX, sBone.ScaleY, sBone.Rotation, false); }));
                }
            }
            _objPreTranslatedGrid = null;
        }
 public void PotentialInputGrid()
 {
     if(SelectedItem is Texture2D)
         _objPreTranslatedGrid = new Texture2D((Texture2D) SelectedItem);
     else if (SelectedItem is Bone)
         _objPreTranslatedGrid = new Bone((Bone) SelectedItem);
 }