public static void SetCursorFromVector3(Vector2 currentPosition, Vector2 lastPosition)
        {
            Vector3 delta = currentPosition - lastPosition;
            float angle = Mathf.Rad2Deg * Mathf.Atan2(delta.y, delta.x);

            while (angle < 0)
            {
                angle += 180;
            }

            while (angle > 180)
            {
                angle -= 180;
            }

            if (angle >= 67.5f && angle < 112.5f)
            {
                activeCursor = MouseCursor.ResizeVertical;
            }
            else if (angle >= 112.5f && angle < 157.5f)
            {
                activeCursor = MouseCursor.ResizeUpLeft;
            }
            else if (angle >= 22.5f && angle < 67.5f)
            {
                activeCursor = MouseCursor.ResizeUpRight;
            }
            else
            {
                activeCursor = MouseCursor.ResizeHorizontal;
            }
        }

 public DisplayProvider()
 {
     this.mouseCursor = new MouseCursor();
      this.screenshot = new Screenshot();
      this.tracker = new BoundsTracker();
      this.waterMark = new WaterMark();
 }

		public ControlTransformer(Service service)
		{
			uiMouseCursor = new MouseCursor(service) { UpdatePriority = Priority.First };
			isTransforming = false;
			Messenger.Default.Register<string>(this, "SetDefaultCursor", SetDefaultCursor);
			Messenger.Default.Register<string>(this, "AllowChangeOfCursor", AllowChangeOfCursor);
			canChangeCursor = false;
		}

    public void Start()
    {
        cur_mode = iMode.MODE_IDENTIFY;

        scr_mouse = GameObject.Find("Main Camera").GetComponent<MouseCursor>();

        UpdateCursor();
    }

        public static CursorChangeToken ChangeCursor(this IView view, MouseCursor cursor)
        {
            Verify.Argument.IsNotNull(view, "view");

            var oldCursor = view.MouseCursor;
            view.MouseCursor = cursor;
            return new CursorChangeToken(view, oldCursor);
        }

 private static Vector2 ScaleSlider(int id, Vector2 pos, MouseCursor cursor, Rect cursorRect)
 {
   Vector2 vector2_1 = (Vector2) Handles.matrix.MultiplyPoint((Vector3) pos);
   Event current = Event.current;
   switch (current.GetTypeForControl(id))
   {
     case EventType.MouseDown:
       if (current.button == 0 && cursorRect.Contains(Event.current.mousePosition) && !current.alt)
       {
         int num = id;
         GUIUtility.keyboardControl = num;
         GUIUtility.hotControl = num;
         SpriteEditorHandles.s_CurrentMousePosition = current.mousePosition;
         SpriteEditorHandles.s_DragStartScreenPosition = current.mousePosition;
         SpriteEditorHandles.s_DragScreenOffset = SpriteEditorHandles.s_CurrentMousePosition - vector2_1;
         current.Use();
         EditorGUIUtility.SetWantsMouseJumping(1);
         break;
       }
       break;
     case EventType.MouseUp:
       if (GUIUtility.hotControl == id && (current.button == 0 || current.button == 2))
       {
         GUIUtility.hotControl = 0;
         current.Use();
         EditorGUIUtility.SetWantsMouseJumping(0);
         break;
       }
       break;
     case EventType.MouseDrag:
       if (GUIUtility.hotControl == id)
       {
         SpriteEditorHandles.s_CurrentMousePosition += current.delta;
         Vector2 vector2_2 = pos;
         pos = (Vector2) Handles.s_InverseMatrix.MultiplyPoint((Vector3) SpriteEditorHandles.s_CurrentMousePosition);
         if (!Mathf.Approximately((vector2_2 - pos).magnitude, 0.0f))
           GUI.changed = true;
         current.Use();
         break;
       }
       break;
     case EventType.KeyDown:
       if (GUIUtility.hotControl == id && current.keyCode == KeyCode.Escape)
       {
         pos = (Vector2) Handles.s_InverseMatrix.MultiplyPoint((Vector3) (SpriteEditorHandles.s_DragStartScreenPosition - SpriteEditorHandles.s_DragScreenOffset));
         GUIUtility.hotControl = 0;
         GUI.changed = true;
         current.Use();
         break;
       }
       break;
     case EventType.Repaint:
       EditorGUIUtility.AddCursorRect(cursorRect, cursor, id);
       break;
   }
   return pos;
 }

		public static void CustomActionField(Rect fieldRect, Action action, bool showCursorPredicate, bool clickPredicate, MouseCursor cursor)
		{
			if (showCursorPredicate)
				AddCursorRect(fieldRect, cursor);
			if (fieldRect.Contains(Event.current.mousePosition))
			{
				if (clickPredicate)
					action();
			}
		}

 public CursorHighlightOptions()
 {
     InitializeComponent();
      //
      this.mouseCursor = new MouseCursor();
      //
      this.tbRadious.Minimum = minRadious;
      this.tbRadious.Maximum = maxRadious;
      this.Color = Color.FromName(defaultColorString);
      this.Radious = defaultRadious;
 }

 /// <summary>
 /// Creates a <see cref="MouseCursor"/> based on the specified image
 /// </summary>
 /// <param name="cursorUri">The <see cref="Uri"/> of the image</param>
 /// <returns>A <see cref="MouseCursor"/></returns>
 public static MouseCursor FromUri(Uri cursorUri)
 {
     Stream bitmapStream;
     Bitmap bitmap;
     OpenTK.MouseCursor cursorObject;
     MouseCursor cursor;
     bitmapStream = Application.GetResourceStream(cursorUri);
     bitmap = new Bitmap(bitmapStream);
     var data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, 32, 32), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
     cursorObject = new OpenTK.MouseCursor(0,0,32, 32, data.Scan0);
     bitmap.UnlockBits(data);
     cursor = new MouseCursor(cursorObject);
     return cursor;
 }

 internal static Vector2 PointSlider(Vector2 pos, MouseCursor cursor, GUIStyle dragDot, GUIStyle dragDotActive)
 {
   int controlId = GUIUtility.GetControlID("Slider1D".GetHashCode(), FocusType.Keyboard);
   Vector2 vector2 = (Vector2) Handles.matrix.MultiplyPoint((Vector3) pos);
   Rect rect = new Rect(vector2.x - dragDot.fixedWidth * 0.5f, vector2.y - dragDot.fixedHeight * 0.5f, dragDot.fixedWidth, dragDot.fixedHeight);
   if (Event.current.GetTypeForControl(controlId) == EventType.Repaint)
   {
     if (GUIUtility.hotControl == controlId)
       dragDotActive.Draw(rect, GUIContent.none, controlId);
     else
       dragDot.Draw(rect, GUIContent.none, controlId);
   }
   return SpriteEditorHandles.ScaleSlider(pos, cursor, rect);
 }

		public static void PingField(UnityObject obj, bool showPredicate, bool clickPredicate, MouseCursor cursor = MouseCursor.Zoom)
		{
			PingField(GetLastRect(), obj, showPredicate, clickPredicate, cursor);
		}

	bool TryScaleButton(Vector3 position, float size)
	{
		size *= HandleUtility.GetHandleSize(position);
		if (Vector3.Distance(mousePosition, position) < size)
		{
			if (e.type == EventType.MouseDown)
				return true;
			else
			{
				mouseCursor = MouseCursor.ScaleArrow;
				Handles.color = Color.green;
			}
		}
		else
			Handles.color = Color.white;
		var buffer = size / 4;
		Handles.DrawLine(new Vector3(position.x - size - buffer, position.y), new Vector3(position.x - size + buffer, position.y));
		Handles.DrawLine(new Vector3(position.x + size - buffer, position.y), new Vector3(position.x + size + buffer, position.y));
		Handles.DrawLine(new Vector3(position.x, position.y - size - buffer), new Vector3(position.x, position.y - size + buffer));
		Handles.DrawLine(new Vector3(position.x, position.y + size - buffer), new Vector3(position.x, position.y + size + buffer));
		Handles.RectangleCap(0, position, Quaternion.identity, size);
		return false;
	}

	bool TryHoverCurvePoint(out int index)
	{
		if (TryHover(curvePoints, Color.white, out index))
		{
			mouseCursor = MouseCursor.MoveArrow;
			return true;
		}
		return false;
	}

	void OnSceneGUI()
	{
		if (target == null)
			return;

		if (KeyPressed(editKey))
			editing = !editing;

		if (editing)
		{
			//Update lists
			if (keyPoints == null)
			{
				keyPoints = new List<Vector3>(polyMesh.keyPoints);
				curvePoints = new List<Vector3>(polyMesh.curvePoints);
				isCurve = new List<bool>(polyMesh.isCurve);
			}

			//Crazy hack to register undo
			if (undoCallback == null)
			{
				undoCallback = typeof(EditorApplication).GetField("undoRedoPerformed", BindingFlags.NonPublic | BindingFlags.Static);
				if (undoCallback != null)
					undoCallback.SetValue(null, new EditorApplication.CallbackFunction(OnUndoRedo));
			}

			//Load handle matrix
			Handles.matrix = polyMesh.transform.localToWorldMatrix;

			//Draw points and lines
			DrawAxis();
			Handles.color = Color.white;
			for (int i = 0; i < keyPoints.Count; i++)
			{
				Handles.color = nearestLine == i ? Color.green : Color.white;
				DrawSegment(i);
				if (selectedIndices.Contains(i))
				{
					Handles.color = Color.green;
					DrawCircle(keyPoints[i], 0.08f);
				}
				else
					Handles.color = Color.white;
				DrawKeyPoint(i);
				if (isCurve[i])
				{
					Handles.color = (draggingCurve && dragIndex == i) ? Color.white : Color.blue;
					DrawCurvePoint(i);
				}
			}

			//Quit on tool change
			if (e.type == EventType.KeyDown)
			{
				switch (e.keyCode)
				{
				case KeyCode.Q:
				case KeyCode.W:
				case KeyCode.E:
				case KeyCode.R:
					return;
				}
			}

			//Quit if panning or no camera exists
			if (Tools.current == Tool.View || (e.isMouse && e.button > 0) || Camera.current == null || e.type == EventType.ScrollWheel)
				return;

			//Quit if laying out
			if (e.type == EventType.Layout)
			{
				HandleUtility.AddDefaultControl(GUIUtility.GetControlID(FocusType.Passive));
				return;
			}

			//Cursor rectangle
			EditorGUIUtility.AddCursorRect(new Rect(0, 0, Camera.current.pixelWidth, Camera.current.pixelHeight), mouseCursor);
			mouseCursor = MouseCursor.Arrow;

			//Extrude key state
			if (e.keyCode == extrudeKey)
			{
				if (extrudeKeyDown)
				{
					if (e.type == EventType.KeyUp)
						extrudeKeyDown = false;
				}
				else if (e.type == EventType.KeyDown)
					extrudeKeyDown = true;
			}

			//Update matrices and snap
			worldToLocal = polyMesh.transform.worldToLocalMatrix;
			inverseRotation = Quaternion.Inverse(polyMesh.transform.rotation) * Camera.current.transform.rotation;
			snap = gridSnap;
			
			//Update mouse position
			screenMousePosition = new Vector3(e.mousePosition.x, Camera.current.pixelHeight - e.mousePosition.y);
			var plane = new Plane(-polyMesh.transform.forward, polyMesh.transform.position);
			var ray = Camera.current.ScreenPointToRay(screenMousePosition);
//.........这里部分代码省略.........

 internal static Vector2 ScaleSlider(Vector2 pos, MouseCursor cursor, Rect cursorRect)
 {
     return ScaleSlider(GUIUtility.GetControlID("Slider1D".GetHashCode(), FocusType.Keyboard), pos, cursor, cursorRect);
 }

 private void HandleBorderPointSlider(ref float x, ref float y, MouseCursor mouseCursor, bool isHidden, GUIStyle dragDot, GUIStyle dragDotActive, Color color)
 {
     Color color2 = GUI.color;
     if (isHidden)
     {
         GUI.color = new Color(0f, 0f, 0f, 0f);
     }
     else
     {
         GUI.color = color;
     }
     Vector2 vector = SpriteEditorHandles.PointSlider(new Vector2(x, y), mouseCursor, dragDot, dragDotActive);
     x = vector.x;
     y = vector.y;
     GUI.color = color2;
 }

 internal static Vector2 PointSlider(Vector2 pos, MouseCursor cursor, GUIStyle dragDot, GUIStyle dragDotActive)
 {
     int controlID = GUIUtility.GetControlID("Slider1D".GetHashCode(), FocusType.Keyboard);
     Vector2 vector = Handles.matrix.MultiplyPoint((Vector3) pos);
     Rect position = new Rect(vector.x - (dragDot.fixedWidth * 0.5f), vector.y - (dragDot.fixedHeight * 0.5f), dragDot.fixedWidth, dragDot.fixedHeight);
     if (Event.current.GetTypeForControl(controlID) == EventType.Repaint)
     {
         if (GUIUtility.hotControl == controlID)
         {
             dragDotActive.Draw(position, GUIContent.none, controlID);
         }
         else
         {
             dragDot.Draw(position, GUIContent.none, controlID);
         }
     }
     return ScaleSlider(pos, cursor, position);
 }

		public static void SelectField(UnityObject obj, MouseCursor cursor = MouseCursor.Link)
		{
			SelectField(GetLastRect(), obj, cursor);
		}

	//Update state
	State UpdateState()
	{
		switch (state)
		{
			//Hovering
		case State.Hover:

			DrawNearestLineAndSplit();

			if (Tools.current == Tool.Move && TryDragSelected())
				return State.DragSelected;
			if (Tools.current == Tool.Rotate && TryRotateSelected())
				return State.RotateSelected;
			if (Tools.current == Tool.Scale && TryScaleSelected())
				return State.ScaleSelected;
			if (Tools.current == Tool.Move && TryExtrude())
				return State.Extrude;

			if (TrySelectAll())
				return State.Hover;
			if (TrySplitLine())
				return State.Hover;
			if (TryDeleteSelected())
				return State.Hover;

			if (TryHoverCurvePoint(out dragIndex) && TryDragCurvePoint(dragIndex))
				return State.Drag;
			if (TryHoverKeyPoint(out dragIndex) && TryDragKeyPoint(dragIndex))
				return State.Drag;
			if (TryBoxSelect())
				return State.BoxSelect;

			break;

			//Dragging
		case State.Drag:
			mouseCursor = MouseCursor.MoveArrow;
			DrawCircle(keyPoints[dragIndex], clickRadius);
			if (draggingCurve)
				MoveCurvePoint(dragIndex, mousePosition - clickPosition);
			else
				MoveKeyPoint(dragIndex, mousePosition - clickPosition);
			if (TryStopDrag())
				return State.Hover;
			break;

			//Box Selecting
		case State.BoxSelect:
			if (TryBoxSelectEnd())
				return State.Hover;
			break;

			//Dragging selected
		case State.DragSelected:
			mouseCursor = MouseCursor.MoveArrow;
			MoveSelected(mousePosition - clickPosition);
			if (TryStopDrag())
				return State.Hover;
			break;

			//Rotating selected
		case State.RotateSelected:
			mouseCursor = MouseCursor.RotateArrow;
			RotateSelected();
			if (TryStopDrag())
				return State.Hover;
			break;

			//Scaling selected
		case State.ScaleSelected:
			mouseCursor = MouseCursor.ScaleArrow;
			ScaleSelected();
			if (TryStopDrag())
				return State.Hover;
			break;

			//Extruding
		case State.Extrude:
			mouseCursor = MouseCursor.MoveArrow;
			MoveSelected(mousePosition - clickPosition);
			if (doExtrudeUpdate && mousePosition != clickPosition)
			{
				UpdatePoly(false, false);
				doExtrudeUpdate = false;
			}
			if (TryStopDrag())
				return State.Hover;
			break;
		}
		return state;
	}

	bool TryRotateButton(Vector3 position, float size)
	{
		size *= HandleUtility.GetHandleSize(position);
		var dist = Vector3.Distance(mousePosition, position);
		var buffer = size / 4;
		if (dist < size + buffer && dist > size - buffer)
		{
			if (e.type == EventType.MouseDown)
				return true;
			else
			{
				mouseCursor = MouseCursor.RotateArrow;
				Handles.color = Color.green;
			}
		}
		else
			Handles.color = Color.white;
		Handles.CircleCap(0, position, inverseRotation, size - buffer / 2);
		Handles.CircleCap(0, position, inverseRotation, size + buffer / 2);
		return false;
	}