From 9e49f7a2615286eaad7e8549bb79bae5c10c900f Mon Sep 17 00:00:00 2001
From: wells.liu <wells.liu@broconcentric.com>
Date: 星期六, 11 七月 2020 10:21:27 +0800
Subject: [PATCH] Merge branch 'master' of http://gitblit.broconcentric.com:8088/r/M071

---
 src/Bro.UI.Model.Winform/ElementBase.cs |  354 ++++++++++++++++++++++++++++++++++++++++++++++++++++-------
 1 files changed, 312 insertions(+), 42 deletions(-)

diff --git a/src/Bro.UI.Model.Winform/ElementBase.cs b/src/Bro.UI.Model.Winform/ElementBase.cs
index 521dda8..c0feb9d 100644
--- a/src/Bro.UI.Model.Winform/ElementBase.cs
+++ b/src/Bro.UI.Model.Winform/ElementBase.cs
@@ -140,13 +140,20 @@
         //[JsonIgnore]
         //protected Pen PenTextNG = new Pen(Color.Red, 2);
 
+        ///// <summary>
+        ///// 瀛椾綋澶у皬
+        ///// </summary>
+        //[Category("鏄剧ず灞炴��")]
+        //[Description("瀛椾綋澶у皬")]
+        ////[Browsable(false)]
+        //public virtual float FontSize { get; set; } = 15;
         /// <summary>
         /// 瀛椾綋澶у皬
         /// </summary>
         [Category("鏄剧ず灞炴��")]
-        [Description("瀛椾綋澶у皬")]
-        //[Browsable(false)]
-        public virtual float FontSize { get; set; } = 15;
+        [Description("瀛椾綋璁剧疆")]
+        public virtual Font Font { get; set; } = new Font(new FontFamily("Tahoma"), 15, GraphicsUnit.World);
+
         /// <summary>
         /// 瀛椾綋鍜屽熀鍏冪殑璺濈
         /// </summary>
@@ -183,9 +190,8 @@
                 if (state != value)
                 {
                     ElementState preState = state;
-                    state = value;
+                    Set(ref state, value);
                     EventRouter.ChangeElementsMouseState?.Invoke(this, preState, state);
-
                     switch (state)
                     {
                         case ElementState.MouseHover:
@@ -236,16 +242,20 @@
             if (State == ElementState.MeasureDoneNG || State == ElementState.MeasureDoneOK)
                 return;
 
-            if (State == ElementState.MouseInSide)
+            //if (State == ElementState.MouseInSide)
+            //{
+            //    State = ElementState.Selected;
+            //}
+            //else if (State == ElementState.Selected || State == ElementState.Moving)
+            //{
+            //    if (IsMouseInSide(p))
+            //    {
+            //        State = ElementState.MouseInSide;
+            //    }
+            //}
+            if (IsMouseInSide(p))
             {
                 State = ElementState.Selected;
-            }
-            else if (State == ElementState.Selected || State == ElementState.Moving)
-            {
-                if (IsMouseInSide(p))
-                {
-                    State = ElementState.MouseInSide;
-                }
             }
         }
 
@@ -255,22 +265,59 @@
 
         public virtual void OnMouseDown(Point p)
         {
-            switch (State)
+            //switch (State)
+            //{
+            //    case ElementState.New:
+            //        OnMouseDownWhenNew(p);
+            //        break;
+            //    case ElementState.MouseHover:
+            //        break;
+            //    case ElementState.MouseInSide:
+            //        State = ElementState.Selected;
+            //        break;
+            //    case ElementState.Selected:
+            //        _startPoint = p;
+            //        State = ElementState.Moving;
+            //        break;
+            //    case ElementState.Normal:
+            //        break;
+            //}
+
+            if (IsMouseCanMoveElement(p) && State == ElementState.Selected)
             {
-                case ElementState.New:
-                    OnMouseDownWhenNew(p);
-                    break;
-                case ElementState.MouseHover:
-                    break;
-                case ElementState.MouseInSide:
-                    State = ElementState.Selected;
-                    break;
-                case ElementState.Selected:
-                    _startPoint = p;
-                    State = ElementState.Moving;
-                    break;
-                case ElementState.Normal:
-                    break;
+                State = ElementState.Moving;
+            }
+            else if (IsMouseCanStretchBottom(p) && State == ElementState.CanStretchBottom)
+            {
+                State = ElementState.StretchingBottom;
+            }
+            else if (IsMouseCanStretchTop(p) && State == ElementState.CanStretchTop)
+            {
+                State = ElementState.StretchingTop;
+            }
+            else if (IsMouseCanStretchLeft(p) && State == ElementState.CanStretchLeft)
+            {
+                State = ElementState.StretchingLeft;
+            }
+            else if (IsMouseCanStretchRight(p) && State == ElementState.CanStretchRight)
+            {
+                State = ElementState.StretchingRight;
+            }
+            else if (IsMouseCanStretchLeftLowerCorner(p) && State == ElementState.CanStretchLeftLowerCorner)
+            {
+                State = ElementState.StretchingLeftLowerCorner;
+            }
+            else if (IsMouseCanStretchLeftUpperCorner(p) && State == ElementState.CanStretchLeftUpperCorner)
+            {
+                State = ElementState.StretchingLeftUpperCorner;
+            }
+            else if (IsMouseCanStretchRightLowerCorner(p) && State == ElementState.CanStretchRightLowerCorner)
+            {
+                State = ElementState.StretchingRightLowerCorner;
+            }
+            else if (IsMouseCanStretchRightUpperCorner(p) && State == ElementState.CanStretchRightUpperCorner)
+            {
+                State = ElementState.StretchingRightUpperCorner;
             }
         }
 
@@ -282,27 +329,133 @@
                     OnMouseMoveWhenNew(p);
                     break;
                 case ElementState.Selected:
+                    if (IsMouseCanStretchLeft(p))
+                    {
+                        State = ElementState.CanStretchLeft;
+                    }
+                    else if (IsMouseCanStretchRight(p))
+                    {
+                        State = ElementState.CanStretchRight;
+                    }
+                    else if (IsMouseCanStretchTop(p))
+                    {
+                        State = ElementState.CanStretchTop;
+                    }
+                    else if (IsMouseCanStretchBottom(p))
+                    {
+                        State = ElementState.CanStretchBottom;
+                    }
+                    else if (IsMouseCanStretchLeftLowerCorner(p))
+                    {
+                        State = ElementState.CanStretchLeftLowerCorner;
+                    }
+                    else if (IsMouseCanStretchLeftUpperCorner(p))
+                    {
+                        State = ElementState.CanStretchLeftUpperCorner;
+                    }
+                    else if (IsMouseCanStretchRightLowerCorner(p))
+                    {
+                        State = ElementState.CanStretchRightLowerCorner;
+                    }
+                    else if (IsMouseCanStretchRightUpperCorner(p))
+                    {
+                        State = ElementState.CanStretchRightUpperCorner;
+                    }
+
                     break;
                 case ElementState.Moving:
                     _currentPoint = p;
-                    Translate(_currentPoint.X - _startPoint.X, _currentPoint.Y - _startPoint.Y);
-                    _startPoint = _currentPoint;
+                    //Translate(_currentPoint.X - _startPoint.X, _currentPoint.Y - _startPoint.Y);
+                    //_startPoint = _currentPoint;
+                    Relocate(p);
                     break;
                 case ElementState.MouseHover:
                 case ElementState.MouseInSide:
                 case ElementState.Normal:
-                    if (IsMouseInSide(p))
+                    //if (IsMouseInSide(p))
+                    //{
+                    //    State = ElementState.MouseInSide;
+                    //}
+                    //else if (IsMouseHover(p))
+                    //{
+                    //    State = ElementState.MouseHover;
+                    //}
+                    //else
+                    //{
+                    //    State = ElementState.Normal;
+                    //}
+                    break;
+                case ElementState.CanStretchBottom:
+                    if (!IsMouseCanStretchBottom(p))
                     {
-                        State = ElementState.MouseInSide;
+                        State = ElementState.Selected;
                     }
-                    else if (IsMouseHover(p))
+                    break;
+                case ElementState.CanStretchTop:
+                    if (!IsMouseCanStretchTop(p))
                     {
-                        State = ElementState.MouseHover;
+                        State = ElementState.Selected;
                     }
-                    else
+                    break;
+                case ElementState.CanStretchLeft:
+                    if (!IsMouseCanStretchLeft(p))
                     {
-                        State = ElementState.Normal;
+                        State = ElementState.Selected;
                     }
+                    break;
+                case ElementState.CanStretchRight:
+                    if (!IsMouseCanStretchRight(p))
+                    {
+                        State = ElementState.Selected;
+                    }
+                    break;
+                case ElementState.CanStretchLeftUpperCorner:
+                    if (!IsMouseCanStretchLeftUpperCorner(p))
+                    {
+                        State = ElementState.Selected;
+                    }
+                    break;
+                case ElementState.CanStretchLeftLowerCorner:
+                    if (!IsMouseCanStretchLeftLowerCorner(p))
+                    {
+                        State = ElementState.Selected;
+                    }
+                    break;
+                case ElementState.CanStretchRightLowerCorner:
+                    if (!IsMouseCanStretchRightLowerCorner(p))
+                    {
+                        State = ElementState.Selected;
+                    }
+                    break;
+                case ElementState.CanStretchRightUpperCorner:
+                    if (!IsMouseCanStretchRightUpperCorner(p))
+                    {
+                        State = ElementState.Selected;
+                    }
+                    break;
+                case ElementState.StretchingTop:
+                    StretchTop(p);
+                    break;
+                case ElementState.StretchingBottom:
+                    StretchBottom(p);
+                    break;
+                case ElementState.StretchingLeft:
+                    StretchLeft(p);
+                    break;
+                case ElementState.StretchingRight:
+                    StretchRight(p);
+                    break;
+                case ElementState.StretchingLeftLowerCorner:
+                    StretchLeftLowerCorner(p);
+                    break;
+                case ElementState.StretchingLeftUpperCorner:
+                    StretchLeftUpperCorner(p);
+                    break;
+                case ElementState.StretchingRightLowerCorner:
+                    StretchRightLowerCorner(p);
+                    break;
+                case ElementState.StretchingRightUpperCorner:
+                    StretchRightUpperCorner(p);
                     break;
             }
         }
@@ -312,15 +465,48 @@
             switch (State)
             {
                 case ElementState.Moving:
-                    //Calculate(null);
                     State = ElementState.Selected;
                     break;
                 case ElementState.Selected:
-                    //Calculate(null);
+                    if (!IsMouseInSide(p))
+                    {
+                        State = ElementState.Normal;
+                    }
+                    break;
+                case ElementState.StretchingBottom:
+                    State = ElementState.CanStretchBottom;
+                    break;
+                case ElementState.StretchingLeft:
+                    State = ElementState.CanStretchLeft;
+                    break;
+                case ElementState.StretchingRight:
+                    State = ElementState.CanStretchRight;
+                    break;
+                case ElementState.StretchingTop:
+                    State = ElementState.CanStretchTop;
+                    break;
+                case ElementState.StretchingLeftLowerCorner:
+                    State = ElementState.CanStretchLeftLowerCorner;
+                    break;
+                case ElementState.StretchingLeftUpperCorner:
+                    State = ElementState.CanStretchLeftUpperCorner;
+                    break;
+                case ElementState.StretchingRightUpperCorner:
+                    State = ElementState.CanStretchRightUpperCorner;
+                    break;
+                case ElementState.StretchingRightLowerCorner:
+                    State = ElementState.CanStretchRightLowerCorner;
                     break;
                 default:
+                    State = ElementState.Normal;
                     break;
             }
+
+            AfterTranformOp();
+        }
+
+        public virtual void AfterTranformOp()
+        {
         }
 
         #region 褰撳熀鍏冪姸鎬佷负鏂板缓鎴栧彲缂栬緫鏃剁殑榧犳爣鎿嶄綔鍔ㄤ綔
@@ -358,12 +544,96 @@
         public abstract bool IsMouseInSide(Point p);
 
         public abstract bool IsIntersect(Rectangle rect);
+        #region Move & Stretch & Move Anchor
+        public virtual bool IsMouseCanMoveElement(Point p)
+        {
+            return false;
+        }
 
-        public abstract void CalculateBaseRectangle();
+        public virtual bool IsMouseCanStretchLeft(Point p)
+        {
+            return false;
+        }
+
+        public virtual bool IsMouseCanStretchRight(Point p)
+        {
+            return false;
+        }
+
+        public virtual bool IsMouseCanStretchTop(Point p)
+        {
+            return false;
+        }
+
+        public virtual bool IsMouseCanStretchBottom(Point p)
+        {
+            return false;
+        }
+
+        public virtual void StretchLeft(Point p)
+        {
+        }
+
+        public virtual void StretchRight(Point p)
+        {
+        }
+
+        public virtual void StretchTop(Point p)
+        {
+        }
+
+        public virtual void StretchBottom(Point p)
+        {
+        }
+
+        public virtual bool IsMouseCanStretchLeftUpperCorner(Point p)
+        {
+            return false;
+        }
+
+        public virtual bool IsMouseCanStretchRightUpperCorner(Point p)
+        {
+            return false;
+        }
+
+        public virtual bool IsMouseCanStretchLeftLowerCorner(Point p)
+        {
+            return false;
+        }
+
+        public virtual bool IsMouseCanStretchRightLowerCorner(Point p)
+        {
+            return false;
+        }
+
+        public virtual void StretchLeftUpperCorner(Point p)
+        {
+        }
+
+        public virtual void StretchRightUpperCorner(Point p)
+        {
+        }
+
+        public virtual void StretchLeftLowerCorner(Point p)
+        {
+        }
+
+        public virtual void StretchRightLowerCorner(Point p)
+        {
+        }
+
+        public virtual bool IsMouseCanMoveAnchor(Point p)
+        {
+            return false;
+        }
+        #endregion
+
         #endregion
 
         #region 鍙樺舰鎿嶄綔
         public abstract void Translate(int x, int y);
+
+        public virtual void Relocate(Point point) { }
 
         //public abstract void RotateAt(int x, int y, float degree);
         #endregion
@@ -386,11 +656,11 @@
         /// 绠楁硶
         /// </summary>
         /// <param name="paras">璁$畻鍙傛暟</param>
-        public abstract void Calculate(Bitmap image);
+        public virtual void Calculate(Bitmap image) { }
 
-        public abstract void Calculate(IntPtr imagePtr, int ptrSize, int imageWidth, int imageHeight);
+        public virtual void Calculate(IntPtr imagePtr, int ptrSize, int imageWidth, int imageHeight) { }
 
-        public abstract void Calculate(string imagePath);
+        public virtual void Calculate(string imagePath) { }
         #endregion
 
         #region 鍥剧墖淇濆瓨

--
Gitblit v1.8.0