NGUI Version 3.9.0

  1. //----------------------------------------------
  2. //            NGUI: Next-Gen UI kit
  3. // Copyright © 2011-2015 Tasharen Entertainment
  4. //----------------------------------------------
  6. using UnityEngine;
  7. using UnityEditor;
  8. using System.Collections.Generic;
  10. /// <summary>
  11. /// Inspector class used to edit UIWidgets.
  12. /// </summary>
  14. [CanEditMultipleObjects]
  15. [CustomEditor(typeof(UIWidget), true)]
  16. public class UIWidgetInspector : UIRectEditor
  17. {
  18. 	static public new UIWidgetInspector instance; // 
  20. 	public enum Action // YUTODO这个什么作用？
  21. 	{
  22. 		None,
  23. 		Move, // 移动
  24. 		Scale,// 缩放
  25. 		Rotate,
  26. 	}
  28. 	Action mAction = Action.None;
  29. 	Action mActionUnderMouse = Action.None;
  30. 	bool mAllowSelection = true;
  32. 	protected UIWidget mWidget; // 保存一个widget
  34. 	static protected bool mUseShader = false;// 默认不使用shader
  36.     // GUIStyle 是什么鬼？
  37.     // 各种颜色的点
  38. 	static GUIStyle mBlueDot = null; //  蓝点？
  39. 	static GUIStyle mYellowDot = null;
  40. 	static GUIStyle mRedDot = null;
  41. 	static GUIStyle mOrangeDot = null;
  42. 	static GUIStyle mGreenDot = null;
  43. 	static GUIStyle mGreyDot = null;
  44. 	static MouseCursor mCursor = MouseCursor.Arrow; // 还能控制鼠标光标？666
  46.     // 枢轴点
  47. 	static public UIWidget.Pivot[] pivotPoints =
  48. 	{
  49. 		UIWidget.Pivot.BottomLeft,
  50. 		UIWidget.Pivot.TopLeft,
  51. 		UIWidget.Pivot.TopRight,
  52. 		UIWidget.Pivot.BottomRight,
  53. 		UIWidget.Pivot.Left,
  54. 		UIWidget.Pivot.Top,
  55. 		UIWidget.Pivot.Right,
  56. 		UIWidget.Pivot.Bottom,
  57. 	};
  59.     //
  60. 	static int s_Hash = "WidgetHash".GetHashCode();
  62.     // 坐标
  63. 	Vector3 mLocalPos = Vector3.zero;
  64. 	Vector3 mWorldPos = Vector3.zero;
  66.     // 起始宽高
  67. 	int mStartWidth = 0;
  68. 	int mStartHeight = 0;
  70.     // 起始拖动和鼠标？
  71. 	Vector3 mStartDrag = Vector3.zero;
  72. 	Vector2 mStartMouse = Vector2.zero;
  74.     // 起始方向和旋转角度
  75. 	Vector3 mStartRot = Vector3.zero;
  76. 	Vector3 mStartDir = Vector3.right;
  78.     // 起始的上下左右？
  79. 	Vector2 mStartLeft = Vector2.zero;
  80. 	Vector2 mStartRight = Vector2.zero;
  81. 	Vector2 mStartBottom = Vector2.zero;
  82. 	Vector2 mStartTop = Vector2.zero;
  84.     // 拖动枢轴点 默认为中心
  85. 	UIWidget.Pivot mDragPivot = UIWidget.Pivot.Center;
  87.     /// <summary>
  88.     /// Raycast into the screen.
  89.     /// 判断当前鼠标是否射中传入的平面
  90.     /// </summary>
  91.     /// <param name="corners">传入待检测平面的三个点</param>
  92.     /// <param name="hit">射到的点的坐标</param>
  93.     /// <returns>射到返回true</returns>
  94. 	static public bool Raycast (Vector3[] corners, out Vector3 hit)
  95. 	{
  96. 		Plane plane = new Plane(corners[0], corners[1], corners[2]); // 三点确定一个平面
  97.         Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition); // 转换2D GUI位置到世界空间的ray
  98. 		float dist = 0f;
  99. 		bool isHit = plane.Raycast(ray, out dist); // 检查射线有没有射中平面
  100. 		hit = isHit ? ray.GetPoint(dist) : Vector3.zero; // GetPoint 返回离射线距离为 dist 的那个点的位置。
  101. 		return isHit;
  102. 	}
  104. 	/// <summary>
  105. 	/// Color used by the handles based on the current color scheme.
  106. 	/// 根据当前颜色主题返回颜色
  107. 	/// </summary>
  109. 	static public Color handlesColor
  110. 	{
  111. 		get
  112. 		{
  113. 			if (NGUISettings.colorMode == NGUISettings.ColorMode.Orange)
  114. 			{
  115. 				return new Color(1f, 0.5f, 0f);
  116. 			}
  117. 			else if (NGUISettings.colorMode == NGUISettings.ColorMode.Green)
  118. 			{
  119. 				return Color.green;
  120. 			}
  121. 			return Color.white;
  122. 		}
  123. 	}
  125. 	/// <summary>
  126. 	/// Draw a control dot at the specified world position.
  127. 	/// 在世界坐标绘制控制点
  128. 	/// </summary>
  130. 	static public void DrawKnob (Vector3 point, bool selected, bool canResize, int id)
  131. 	{
  132.         // TODO 这是一种什么赋值方法？
  133. 		if (mGreyDot == null) mGreyDot = "sv_label_0"; // 一种内置的编辑器风格
  134. 		if (mBlueDot == null) mBlueDot = "sv_label_1";
  135. 		if (mGreenDot == null) mGreenDot = "sv_label_3";
  136. 		if (mYellowDot == null) mYellowDot = "sv_label_4";
  137. 		if (mOrangeDot == null) mOrangeDot = "sv_label_5";
  138. 		if (mRedDot == null) mRedDot = "sv_label_6";
  140.         //
  141. 		Vector2 screenPoint = HandleUtility.WorldToGUIPoint(point);
  143.         // 矩阵
  144. #if UNITY_4_3 || UNITY_4_5 || UNITY_4_6
  145. 		Rect rect = new Rect(screenPoint.x - 7f, screenPoint.y - 7f, 14f, 14f);
  146. #else
  147. 		Rect rect = new Rect(screenPoint.x - 5f, screenPoint.y - 9f, 14f, 14f);
  148. #endif
  150.         // 根据传入的状态判断显示的颜色
  151. 		if (selected)
  152. 		{
  153. 			if (NGUISettings.colorMode == NGUISettings.ColorMode.Orange)
  154. 			{
  155. 				mRedDot.Draw(rect, GUIContent.none, id);
  156. 			}
  157. 			else
  158. 			{
  159. 				mOrangeDot.Draw(rect, GUIContent.none, id);
  160. 			}
  161. 		}
  162. 		else if (canResize)
  163. 		{
  164. 			if (NGUISettings.colorMode == NGUISettings.ColorMode.Orange)
  165. 			{
  166. 				mOrangeDot.Draw(rect, GUIContent.none, id);
  167. 			}
  168. 			else if (NGUISettings.colorMode == NGUISettings.ColorMode.Green)
  169. 			{
  170. 				mGreenDot.Draw(rect, GUIContent.none, id);
  171. 			}
  172. 			else
  173. 			{
  174. 				mBlueDot.Draw(rect, GUIContent.none, id);
  175. 			}
  176. 		}
  177. 		else mGreyDot.Draw(rect, GUIContent.none, id); //
  178. 	}
  180. 	/// <summary>
  181. 	/// Screen-space distance from the mouse position to the specified world position.
  182. 	/// 屏幕空间下 鼠标到某点的距离
  183. 	/// </summary>
  185. 	static public float GetScreenDistance (Vector3 worldPos, Vector2 mousePos)
  186. 	{
  187. 		Vector2 screenPos = HandleUtility.WorldToGUIPoint(worldPos);
  188. 		return Vector2.Distance(mousePos, screenPos);
  189. 	}
  191. 	/// <summary>
  192. 	/// Closest screen-space distance from the mouse position to one of the specified world points.
  193. 	/// 屏幕空间下 在鼠标到各点的距离中取最小距离
  194. 	/// </summary>
  196. 	static public float GetScreenDistance (Vector3[] worldPoints, Vector2 mousePos, out int index)
  197. 	{
  198. 		float min = float.MaxValue;
  199. 		index = 0;
  201. 		for (int i = 0; i < worldPoints.Length; ++i)
  202. 		{
  203. 			float distance = GetScreenDistance(worldPoints[i], mousePos);
  205. 			if (distance < min)
  206. 			{
  207. 				index = i;
  208. 				min = distance;
  209. 			}
  210. 		}
  211. 		return min;
  212. 	}
  214. 	/// <summary>
  215. 	/// Set the mouse cursor rectangle, refreshing the screen when it gets changed.
  216. 	/// 鼠标光标类型发生改变时重新设置它的矩形区域
  217. 	/// </summary>
  219. 	static public void SetCursorRect (Rect rect, MouseCursor cursor)
  220. 	{
  221. 		EditorGUIUtility.AddCursorRect(rect, cursor);
  223. 		if (Event.current.type == EventType.MouseMove)
  224. 		{
  225. 			if (mCursor != cursor)
  226. 			{
  227. 				mCursor = cursor;
  228. 				Event.current.Use();
  229. 			}
  230. 		}
  231. 	}
  233.     /// <summary>
  234.     ///
  235.     /// </summary>
  236. 	protected override void OnDisable ()
  237. 	{
  238. 		base.OnDisable();
  239. 		NGUIEditorTools.HideMoveTool(false);
  240. 		instance = null;
  241. 	}
  243. 	/// <summary>
  244. 	/// Convert the specified 4 corners into 8 pivot points (adding left, top, right, bottom -- in that order).
  245. 	/// 把四个角落的坐标数组扩展为八个点的坐标数组
  246. 	/// </summary>
  248. 	static public Vector3[] GetHandles (Vector3[] corners)
  249. 	{
  250. 		Vector3[] v = new Vector3[8];
  252. 		v[0] = corners[0];
  253. 		v[1] = corners[1];
  254. 		v[2] = corners[2];
  255. 		v[3] = corners[3];
  257. 		v[4] = (corners[0] + corners[1]) * 0.5f;
  258. 		v[5] = (corners[1] + corners[2]) * 0.5f;
  259. 		v[6] = (corners[2] + corners[3]) * 0.5f;
  260. 		v[7] = (corners[0] + corners[3]) * 0.5f;
  262. 		return v;
  263. 	}
  265. 	/// <summary>
  266. 	/// Determine what kind of pivot point is under the mouse and update the cursor accordingly.
  267. 	/// 通过鼠标的位置判断应当进行什么样的操作。
  268. 	/// 默认返回 center 锚点，能够缩放时返回 目标锚点
  269. 	/// </summary>
  271. 	static public UIWidget.Pivot GetPivotUnderMouse (Vector3[] worldPos, Event e, bool[] resizable, bool movable, ref Action action)
  272. 	{
  273. 		// Time to figure out what kind of action is underneath the mouse
  274. 		UIWidget.Pivot pivotUnderMouse = UIWidget.Pivot.Center;// 初始化为 锚点中心
  276.         //
  277. 		if (action == Action.None)
  278. 		{
  279. 			int index = 0;
  280. 			float dist = GetScreenDistance(worldPos, e.mousePosition, out index); // 获取最小的距离，并记录最小距离对应点的下标
  281. 			bool alt = (e.modifiers & EventModifiers.Alt) != 0; // 判断是不是按了组合键
  283.             //
  284. 			if (resizable[index] && dist < 10f) // 如果这个位置能动，并且距离小于10f
  285. 			{
  286. 				pivotUnderMouse = pivotPoints[index]; //鼠标点到的枢轴点是index标示出的index
  287. 				action = Action.Scale;// 进行缩放动作
  288. 			}
  289. 			else if (!alt && NGUIEditorTools.SceneViewDistanceToRectangle(worldPos, e.mousePosition) == 0f) // 没有按组合键并且鼠标点在矩形框里面
  290. 			{
  291. 				action = movable ? Action.Move : Action.Rotate; // 能移动仅进行移动，不能移动就进行旋转
  292. 			}
  293. 			else if (dist < 30f)
  294. 			{
  295. 				action = Action.Rotate; // 其他情况就进行旋转
  296. 			}
  297. 		}
  299. 		// Change the mouse cursor to a more appropriate one
  300.         //
  301. 		Vector2[] screenPos = new Vector2[8];
  302. 		for (int i = 0; i < 8; ++i) screenPos[i] = HandleUtility.WorldToGUIPoint(worldPos[i]);
  304. 		Bounds b = new Bounds(screenPos[0], Vector3.zero); // 给定中心点和大小。，后面那个大小代表（width,height,depth）
  305. 		for (int i = 1; i < 8; ++i) b.Encapsulate(screenPos[i]);// 包含八个点的最小矩形框，在这里八个点都恰好在矩形框的边上。
  307.         Vector2 min = b.min;// min = center - extents; extents 是 size 的一半。例如中心点为（0，0，0），extents（2，3，5），那么min（-2，-3，-5）
  308. 		Vector2 max = b.max;
  310.         // 在原来的基础上扩展 30f。depth 没用到所以这里没处理
  311. 		min.x -= 30f;
  312. 		max.x += 30f;
  313. 		min.y -= 30f;
  314. 		max.y += 30f;
  316. 		Rect rect = new Rect(min.x, min.y, max.x - min.x, max.y - min.y); // 获取矩形框
  318.         // 根据动作的状态 显示鼠标光标的形状
  319. 		if (action == Action.Rotate)
  320. 		{
  321. 			SetCursorRect(rect, MouseCursor.RotateArrow);
  322. 		}
  323. 		else if (action == Action.Move)
  324. 		{
  325. 			SetCursorRect(rect, MouseCursor.MoveArrow);
  326. 		}
  327. 		else if (action == Action.Scale)
  328. 		{
  329. 			SetCursorRect(rect, MouseCursor.ScaleArrow);
  330. 		}
  331. 		else SetCursorRect(rect, MouseCursor.Arrow);
  333. 		return pivotUnderMouse;
  334. 	}
  336. 	/// <summary>
  337. 	/// Draw the specified anchor point.
  338. 	/// 绘制黄色的锚点以及连接线、距离标签
  339. 	/// </summary>
  341. 	static public void DrawAnchorHandle (UIRect.AnchorPoint anchor, Transform myTrans, Vector3[] myCorners, int side, int id)
  342. 	{
  343. 		if (!anchor.target) return; // 没有定锚点就不用画了
  345. 		int i0, i1;
  347.         //矩形四个点在数组中的序列与相对位置的关系如下
  348.         //12
  349.         //03
  351.         //根据是哪边的锚点来选出决定那条边的两个顶点
  352. 		if (side == 0)
  353. 		{
  354. 			// Left
  355. 			i0 = 0;
  356. 			i1 = 1;
  357. 		}
  358. 		else if (side == 1)
  359. 		{
  360. 			// Top
  361. 			i0 = 1;
  362. 			i1 = 2;
  363. 		}
  364. 		else if (side == 2)
  365. 		{
  366. 			// Right
  367. 			i0 = 3;
  368. 			i1 = 2;
  369. 		}
  370. 		else
  371. 		{
  372. 			// Bottom
  373. 			i0 = 0;
  374. 			i1 = 3;
  375. 		}
  377.         //
  378. 		Vector3 myPos = (myCorners[i0] + myCorners[i1]) * 0.5f; // 锚点相关位置是对应边的中点
  380. 		Vector3[] sides = null; // 目标对象矩形的四个节点
  382. 		if (anchor.rect != null)
  383. 		{
  384. 			sides = anchor.rect.worldCorners;
  385. 		}
  386. 		else
  387. 		{
  388. #if UNITY_4_3 || UNITY_4_5 || UNITY_4_6
  389. 			Camera cam = anchor.target.camera; // 获取锚点目标的 camera
  390. #else
  391. 			Camera cam = anchor.target.GetComponent<Camera>();
  392. #endif
  393. 			if (cam != null) sides = cam.GetWorldCorners(); // 获取相机的边界
  394. 		}
  396. 		Vector3 theirPos; // 黄点位置，必然在目标矩形上面
  398. 		if (sides != null)
  399. 		{
  400. 			Vector3 v0, v1;
  402. 			if (side == 0 || side == 2)
  403. 			{
  404. 				// Left or right
  405. 				v0 = Vector3.Lerp(sides[0], sides[3], anchor.relative); // 在两个向量V0、V1间做线性插值，根据第三个参数t决定返回某个插值。例如 t=0 返回V0，t=0.5 返回V0、V1的中间插值。
  406. 				v1 = Vector3.Lerp(sides[1], sides[2], anchor.relative); //
  407. 			}
  408. 			else
  409. 			{
  410. 				// Top or bottom
  411. 				v0 = Vector3.Lerp(sides[0], sides[1], anchor.relative);
  412. 				v1 = Vector3.Lerp(sides[3], sides[2], anchor.relative);
  413. 			}
  415.             // 黄点是 myPos 在 v0 和 v1 连接线上的投影点，如果超过v0v1线段，则黄点设置为v0或v1。
  416. 			theirPos = HandleUtility.ProjectPointLine(myPos, v0, v1);
  417. 		}
  418. 		else
  419. 		{
  420. 			theirPos = anchor.target.position;
  421. 		}
  423.         // 画连接线
  424. 		NGUIHandles.DrawShadowedLine(myCorners, myPos, theirPos, Color.yellow);
  426.         // 位置偏离的时候在一定条件下绘制一个标记负值距离的标签
  427. 		if (Event.current.GetTypeForControl(id) == EventType.Repaint) // 控制ID id 当前事件类型如果是重绘
  428. 		{
  429. 			Vector2 screenPoint = HandleUtility.WorldToGUIPoint(theirPos);
  431. #if UNITY_4_3 || UNITY_4_5 || UNITY_4_6
  432. 			Rect rect = new Rect(screenPoint.x - 7f, screenPoint.y - 7f, 14f, 14f);
  433. #else
  434. 			Rect rect = new Rect(screenPoint.x - 5f, screenPoint.y - 9f, 14f, 14f);
  435. #endif
  436. 			if (mYellowDot == null) mYellowDot = "sv_label_4";
  438. 			Vector3 v0 = HandleUtility.WorldToGUIPoint(myPos);
  439. 			Vector3 v1 = HandleUtility.WorldToGUIPoint(theirPos);
  441. 			Handles.BeginGUI(); // 开始一个 2D 绘制块
  443. 			mYellowDot.Draw(rect, GUIContent.none, id); // 绘制黄点
  445. 			Vector3 diff = v1 - v0;
  446. 			bool isHorizontal = Mathf.Abs(diff.x) > Mathf.Abs(diff.y);// 判断是否为水平线
  447. 			float mag = diff.magnitude; // 获取线的长度
  449. 			if ((isHorizontal && mag > 60f) || (!isHorizontal && mag > 30f)) // 长度超过 60 的水平线或者长度大于 30 的竖直线
  450. 			{
  451. 				Vector3 pos = (myPos + theirPos) * 0.5f; //
  452. 				string text = anchor.absolute.ToString();// 
  454. 				GUI.color = Color.yellow;
  456. 				if (side == 0)
  457. 				{
  458.                     if (theirPos.x < myPos.x) //如果目标点的位置比出发点的位置还要靠左，那么显示一个标记距离的label
  459. 						NGUIHandles.DrawCenteredLabel(pos, text);
  460. 				}
  461. 				else if (side == 1)
  462. 				{
  463. 					if (theirPos.y > myPos.y)
  464. 						NGUIHandles.DrawCenteredLabel(pos, text);
  465. 				}
  466. 				else if (side == 2)
  467. 				{
  468. 					if (theirPos.x > myPos.x)
  469. 						NGUIHandles.DrawCenteredLabel(pos, text);
  470. 				}
  471. 				else if (side == 3)
  472. 				{
  473. 					if (theirPos.y < myPos.y)
  474. 						NGUIHandles.DrawCenteredLabel(pos, text);
  475. 				}
  476. 				GUI.color = Color.white;
  477. 			}
  478. 			Handles.EndGUI();
  479. 		}
  480. 	}
  482. 	/// <summary>
  483. 	/// Draw the on-screen selection, knobs, and handle all interaction logic.
  484. 	///
  485. 	/// </summary>
  487. 	public void OnSceneGUI ()
  488. 	{
  489. 		if (Selection.objects.Length > 1) return;  // 选中了多个对象，返回
  490. 		NGUIEditorTools.HideMoveTool(true); // 隐藏移动工具
  491. 		if (!UIWidget.showHandles) return; // 没有需要显示的 handles，返回
  493. 		mWidget = target as UIWidget; // 把选中对象作为一个 UIWidget 组件处理
  495. 		Transform t = mWidget.cachedTransform; // 获取对象的 transform
  497. 		Event e = Event.current;               //
  498. 		int id = GUIUtility.GetControlID(s_Hash, FocusType.Passive); // 获取一个控制ID，这个控制不能获取键盘焦点
  499. 		EventType type = e.GetTypeForControl(id); // 获取控制ID的事件类型
  501. 		Action actionUnderMouse = mAction; // 移动、缩放或是旋转
  502. 		Vector3[] handles = GetHandles(mWidget.worldCorners); // 获取组件的八个枢轴点点
  504.         // 绘制矩形框
  505. 		NGUIHandles.DrawShadowedLine(handles, handles[0], handles[1], handlesColor);
  506. 		NGUIHandles.DrawShadowedLine(handles, handles[1], handles[2], handlesColor);
  507. 		NGUIHandles.DrawShadowedLine(handles, handles[2], handles[3], handlesColor);
  508. 		NGUIHandles.DrawShadowedLine(handles, handles[0], handles[3], handlesColor);
  510. 		// If the widget is anchored, draw the anchors
  511.         // 组件有锚点的话就绘制锚点
  512. 		if (mWidget.isAnchored)
  513. 		{
  514. 			DrawAnchorHandle(mWidget.leftAnchor, mWidget.cachedTransform, handles, 0, id);
  515. 			DrawAnchorHandle(mWidget.topAnchor, mWidget.cachedTransform, handles, 1, id);
  516. 			DrawAnchorHandle(mWidget.rightAnchor, mWidget.cachedTransform, handles, 2, id);
  517. 			DrawAnchorHandle(mWidget.bottomAnchor, mWidget.cachedTransform, handles, 3, id);
  518. 		}
  520.         // 需要时显示细节
  521. 		if (type == EventType.Repaint)
  522. 		{
  523. 			bool showDetails = (mAction == UIWidgetInspector.Action.Scale) || NGUISettings.drawGuides; // 进行缩放时显示细节
  524. 			if (mAction == UIWidgetInspector.Action.None && e.modifiers == EventModifiers.Control) showDetails = true;
  525. 			if (NGUITools.GetActive(mWidget) && mWidget.parent == null) showDetails = true;
  526. 			if (showDetails) NGUIHandles.DrawSize(handles, mWidget.width, mWidget.height);
  527. 		}
  529. 		// Presence of the legacy stretch component prevents resizing
  530.         // TODO 显示原来的轨迹组件放置重绘 ？？
  532. 		bool canResize = (mWidget.GetComponent<UIStretch>() == null); // 没有这个组件说明是可以自由缩放的
  533. 		bool[] resizable = new bool[8]; // 
  535. 		resizable[4] = canResize;	// left
  536. 		resizable[5] = canResize;	// top
  537. 		resizable[6] = canResize;	// right
  538. 		resizable[7] = canResize;	// bottom
  540. 		UILabel lbl = mWidget as UILabel; // 如果这个 widget 组件实际上是个一个 Label 组件
  542. 		if (lbl != null)
  543. 		{
  544. 			if (lbl.overflowMethod == UILabel.Overflow.ResizeFreely) // 如果 label 设置为可以随意缩放，那么其锚点都定住
  545. 			{
  546. 				resizable[4] = false;	// left
  547. 				resizable[5] = false;	// top
  548. 				resizable[6] = false;	// right
  549. 				resizable[7] = false;	// bottom
  550. 			}
  551. 			else if (lbl.overflowMethod == UILabel.Overflow.ResizeHeight) // 如果是高度可以自由缩放，那么上下两个锚点也定住
  552. 			{
  553. 				resizable[5] = false;	// top
  554. 				resizable[7] = false;	// bottom
  555. 			}
  556. 		}
  558. 		if (mWidget.keepAspectRatio == UIWidget.AspectRatioSource.BasedOnHeight) // 基于高度变换，那么左右锚点就不需要设置了
  559. 		{
  560. 			resizable[4] = false;
  561. 			resizable[6] = false;
  562. 		}
  563. 		else if (mWidget.keepAspectRatio == UIWidget.AspectRatioSource.BasedOnWidth)
  564. 		{
  565. 			resizable[5] = false;
  566. 			resizable[7] = false;
  567. 		}
  569.         // 角落的锚点情况根据上下左右的可用情况设置
  570. 		resizable[0] = resizable[7] && resizable[4]; // bottom-left
  571. 		resizable[1] = resizable[5] && resizable[4]; // top-left
  572. 		resizable[2] = resizable[5] && resizable[6]; // top-right
  573. 		resizable[3] = resizable[7] && resizable[6]; // bottom-right
  575.         // 获取锚点，没有的话返回 center
  576. 		UIWidget.Pivot pivotUnderMouse = GetPivotUnderMouse(handles, e, resizable, true, ref actionUnderMouse);
  578. 		switch (type)
  579. 		{
  580. 			case EventType.Repaint: // 绘制控制点
  581. 			{
  582. 				Vector3 v0 = HandleUtility.WorldToGUIPoint(handles[0]);
  583. 				Vector3 v2 = HandleUtility.WorldToGUIPoint(handles[2]);
  585. 				if ((v2 - v0).magnitude > 60f) // 斜边 长度大于 60 才绘制控制点
  586. 				{
  587. 					Vector3 v1 = HandleUtility.WorldToGUIPoint(handles[1]);
  588. 					Vector3 v3 = HandleUtility.WorldToGUIPoint(handles[3]);
  590.                     Handles.BeginGUI();
  591. 					{
  592. 						for (int i = 0; i < 4; ++i)
  593. 							DrawKnob(handles[i], mWidget.pivot == pivotPoints[i], resizable[i], id);
  595. 						if ((v1 - v0).magnitude > 80f)
  596. 						{
  597. 							if (mWidget.leftAnchor.target == null || mWidget.leftAnchor.absolute != 0)
  598. 								DrawKnob(handles[4], mWidget.pivot == pivotPoints[4], resizable[4], id);
  600. 							if (mWidget.rightAnchor.target == null || mWidget.rightAnchor.absolute != 0)
  601. 								DrawKnob(handles[6], mWidget.pivot == pivotPoints[6], resizable[6], id);
  602. 						}
  604. 						if ((v3 - v0).magnitude > 80f)
  605. 						{
  606. 							if (mWidget.topAnchor.target == null || mWidget.topAnchor.absolute != 0)
  607. 								DrawKnob(handles[5], mWidget.pivot == pivotPoints[5], resizable[5], id);
  609. 							if (mWidget.bottomAnchor.target == null || mWidget.bottomAnchor.absolute != 0)
  610. 								DrawKnob(handles[7], mWidget.pivot == pivotPoints[7], resizable[7], id);
  611. 						}
  612. 					}
  613. 					Handles.EndGUI();
  614. 				}
  615. 			}
  616. 			break;
  618. 			case EventType.MouseDown:
  619. 			{
  620. 				if (actionUnderMouse != Action.None)
  621. 				{
  622. 					mStartMouse = e.mousePosition; // 记录鼠标起始位置
  623. 					mAllowSelection = true; // 标记拖动的开始，拖动过程中无法再次选中
  625. 					if (e.button == 1) //
  626. 					{
  627. 						if (e.modifiers == 0) // 没有用组合键
  628. 						{
  629. 							GUIUtility.hotControl = GUIUtility.keyboardControl = id;
  630. 							e.Use(); // 使用该事件，用于表示这个事件已经处理过了
  631. 						}
  632. 					}
  633. 					else if (e.button == 0 && actionUnderMouse != Action.None && Raycast(handles, out mStartDrag)) // 鼠标左键&&能够操作&&点到了这个平面 // TODO 不知道为什么需要这么多判断
  634. 					{
  635. 						mWorldPos = t.position;
  636. 						mLocalPos = t.localPosition;
  637. 						mStartRot = t.localRotation.eulerAngles;
  638. 						mStartDir = mStartDrag - t.position; // 用向量来表示角度，鼠标与中点连线的夹角
  639. 						mStartWidth = mWidget.width;
  640. 						mStartHeight = mWidget.height;
  641.                         // TODO 上下左右，
  642. 						mStartLeft.x = mWidget.leftAnchor.relative;
  643. 						mStartLeft.y = mWidget.leftAnchor.absolute;
  644. 						mStartRight.x = mWidget.rightAnchor.relative;
  645. 						mStartRight.y = mWidget.rightAnchor.absolute;
  646. 						mStartBottom.x = mWidget.bottomAnchor.relative;
  647. 						mStartBottom.y = mWidget.bottomAnchor.absolute;
  648. 						mStartTop.x = mWidget.topAnchor.relative;
  649. 						mStartTop.y = mWidget.topAnchor.absolute;
  651.                         //
  652. 						mDragPivot = pivotUnderMouse;
  653. 						mActionUnderMouse = actionUnderMouse;
  654.                         //
  655. 						GUIUtility.hotControl = GUIUtility.keyboardControl = id;
  656. 						e.Use();
  657. 					}
  658. 				}
  659. 			}
  660. 			break;
  662. 			case EventType.MouseDrag:
  663. 			{
  664. 				// Prevent selection once the drag operation begins
  665.                 // 如果已经进行了拖动操作，那么无法再进行选中了
  666. 				bool dragStarted = (e.mousePosition - mStartMouse).magnitude > 3f;
  667. 				if (dragStarted) mAllowSelection = false;
  669. 				if (GUIUtility.hotControl == id) // 如果热键控制 与 id 一致
  670. 				{
  671. 					e.Use(); // TODO 这个为什么设置在前面？
  673. 					if (mAction != Action.None || mActionUnderMouse != Action.None) //
  674. 					{
  675. 						Vector3 pos;
  677. 						if (Raycast(handles, out pos))
  678. 						{
  679.                             // 拖动开始时进行数据记录
  680. 							if (mAction == Action.None && mActionUnderMouse != Action.None) // 前面的 mAction 用于标记是否是拖动刚开始
  681. 							{
  682. 								// Wait until the mouse moves by more than a few pixels
  683. 								if (dragStarted)
  684. 								{
  685. 									if (mActionUnderMouse == Action.Move) //
  686. 									{
  687. 										NGUISnap.Recalculate(mWidget); // 重新计算
  688. 									}
  689. 									else if (mActionUnderMouse == Action.Rotate) //
  690. 									{
  691. 										mStartRot = t.localRotation.eulerAngles; // 返回欧垃角
  692. 										mStartDir = mStartDrag - t.position; // 旋转的角度
  693. 									}
  694. 									else if (mActionUnderMouse == Action.Scale)
  695. 									{
  696. 										mStartWidth = mWidget.width;
  697. 										mStartHeight = mWidget.height;
  698. 										mDragPivot = pivotUnderMouse;
  699. 									}
  700. 									mAction = actionUnderMouse;
  701. 								}
  702. 							}
  704.                             //
  705. 							if (mAction != Action.None)
  706. 							{
  707.                                 // 设置撤销点
  708. 								NGUIEditorTools.RegisterUndo("Change Rect", t);
  709. 								NGUIEditorTools.RegisterUndo("Change Rect", mWidget);
  711. 								// Reset the widget before adjusting anything
  712.                                 // 在进行任何调整前先进行重置
  713. 								t.position = mWorldPos;
  714. 								mWidget.width = mStartWidth;
  715. 								mWidget.height = mStartHeight;
  716.                                 // widget 的上下左右锚点都重置为初始值
  717. 								mWidget.leftAnchor.Set(mStartLeft.x, mStartLeft.y);
  718. 								mWidget.rightAnchor.Set(mStartRight.x, mStartRight.y);
  719. 								mWidget.bottomAnchor.Set(mStartBottom.x, mStartBottom.y);
  720. 								mWidget.topAnchor.Set(mStartTop.x, mStartTop.y);
  722.                                 // 移动操作
  723. 								if (mAction == Action.Move)
  724. 								{
  725. 									// Move the widget
  726.                                     t.position = mWorldPos + (pos - mStartDrag); // t.position = t.positon + (pos - mStartDrag);//mWorldPos 和 mStartDrag 应该是同一个值，不知道为什么要分开来
  727. 									Vector3 after = t.localPosition; // 
  729. 									bool snapped = false; //
  730. 									Transform parent = t.parent; 
  732. 									if (parent != null)
  733. 									{
  734. 										UIGrid grid = parent.GetComponent<UIGrid>(); // 
  736.                                         // 如果说这个widget的父节点具有 Grid 组件，并且按照 CellSnap 的布局方式进行布局
  737.                                         // 那么根据grid的cell大小进行对齐操作。
  738. 										if (grid != null && grid.arrangement == UIGrid.Arrangement.CellSnap)
  739. 										{
  740. 											snapped = true;
  741. 											if (grid.cellWidth > 0) after.x = Mathf.Round(after.x / grid.cellWidth) * grid.cellWidth;
  742. 											if (grid.cellHeight > 0) after.y = Mathf.Round(after.y / grid.cellHeight) * grid.cellHeight;
  743. 										}
  744. 									}
  746.                                     // 如果还没对齐过，进行对齐
  747. 									if (!snapped)
  748. 									{
  749. 										// Snap the widget
  750. 										after = NGUISnap.Snap(after, mWidget.localCorners, e.modifiers != EventModifiers.Control);
  751. 									}
  753. 									// Calculate the final delta
  754.                                     // 本地坐标的变化量
  755. 									Vector3 localDelta = (after - mLocalPos);
  757. 									// Restore the position
  758. 									t.position = mWorldPos; // 恢复坐标位置
  760. 									// Adjust the widget by the delta
  761.                                     // 根据 delta 来移动 Widget 。 // TODO 这跟直接移动 postion 有什么区别？
  762. 									NGUIMath.MoveRect(mWidget, localDelta.x, localDelta.y);
  763. 								}
  764. 								else if (mAction == Action.Rotate)
  765. 								{
  766.                                     // 这部分代码不是太懂呢。。
  767. 									Vector3 dir = pos - t.position;
  768. 									float angle = Vector3.Angle(mStartDir, dir);
  770. 									if (angle > 0f)
  771. 									{
  772. 										float dot = Vector3.Dot(Vector3.Cross(mStartDir, dir), t.forward);
  773. 										if (dot < 0f) angle = -angle;
  774. 										angle = mStartRot.z + angle; // 为什么要加 z 值
  775. 										angle = (NGUISnap.allow && e.modifiers != EventModifiers.Control) ?
  776. 											Mathf.Round(angle / 15f) * 15f : Mathf.Round(angle);
  777.                                         // 计算欧拉角
  778. 										t.localRotation = Quaternion.Euler(mStartRot.x, mStartRot.y, angle);
  779. 									}
  780. 								}
  781. 								else if (mAction == Action.Scale)
  782. 								{
  783. 									// Move the widget
  784.                                     //
  785. 									t.position = mWorldPos + (pos - mStartDrag);
  787. 									// Calculate the final delta
  788. 									Vector3 localDelta = (t.localPosition - mLocalPos);
  790. 									// Restore the position
  791. 									t.position = mWorldPos;
  793. 									// Adjust the widget's position and scale based on the delta, restricted by the pivot
  794.                                     // 以枢轴点为中心进行缩放
  795. 									NGUIMath.ResizeWidget(mWidget, mDragPivot, localDelta.x, localDelta.y, 2, 2);
  796. 									ReEvaluateAnchorType();
  797. 								}
  798. 							}
  799. 						}
  800. 					}
  801. 				}
  802. 			}
  803. 			break;
  805.                 // 释放鼠标
  806. 			case EventType.MouseUp:
  807. 			{
  808. 				if (e.button == 2) break; // 中键不处理
  810. 				if (GUIUtility.hotControl == id)
  811. 				{
  812.                     // 收尾处理
  813. 					GUIUtility.hotControl = 0;
  814. 					GUIUtility.keyboardControl = 0;
  816.                     //
  817. 					if (e.button < 2)
  818. 					{
  819. 						bool handled = false; 
  821.                         //
  822. 						if (e.button == 1)
  823. 						{
  824. 							// Right-click: Open a context menu listing all widgets underneath
  825. 							NGUIEditorTools.ShowSpriteSelectionMenu(e.mousePosition);
  826. 							handled = true;
  827. 						}
  828. 						else if (mAction == Action.None)
  829. 						{
  830.                             // 选择对象
  831. 							if (mAllowSelection)
  832. 							{
  833. 								// Left-click: Select the topmost widget
  834. 								NGUIEditorTools.SelectWidget(e.mousePosition);
  835. 								handled = true;
  836. 							}
  837. 						}
  838. 						else
  839. 						{
  840. 							// Finished dragging something
  841. 							Vector3 pos = t.localPosition;
  842. 							pos.x = Mathf.Round(pos.x);
  843. 							pos.y = Mathf.Round(pos.y);
  844. 							pos.z = Mathf.Round(pos.z);
  845. 							t.localPosition = pos; //对相对位置进行圆整
  846. 							handled = true;
  847. 						}
  849. 						if (handled) e.Use(); // 如果处理过了，那么该事件结束
  850. 					}
  852. 					// Clear the actions
  853. 					mActionUnderMouse = Action.None;
  854. 					mAction = Action.None;
  855. 				}
  856. 				else if (mAllowSelection) // 没控制但是允许选中，那么选择第一个 widget
  857. 				{
  858. 					List<UIWidget> widgets = NGUIEditorTools.SceneViewRaycast(e.mousePosition);
  859. 					if (widgets.Count > 0) Selection.activeGameObject = widgets[0].gameObject;
  860. 				}
  861. 				mAllowSelection = true;
  862. 			}
  863. 			break;
  865.             // 上下左右键对矩形框进行移动
  866. 			case EventType.KeyDown:
  867. 			{
  868. 				if (e.keyCode == KeyCode.UpArrow)
  869. 				{
  870. 					NGUIEditorTools.RegisterUndo("Nudge Rect", t);
  871. 					NGUIEditorTools.RegisterUndo("Nudge Rect", mWidget);
  872. 					NGUIMath.MoveRect(mWidget, 0f, 1f);
  873. 					e.Use();
  874. 				}
  875. 				else if (e.keyCode == KeyCode.DownArrow)
  876. 				{
  877. 					NGUIEditorTools.RegisterUndo("Nudge Rect", t);
  878. 					NGUIEditorTools.RegisterUndo("Nudge Rect", mWidget);
  879. 					NGUIMath.MoveRect(mWidget, 0f, -1f);
  880. 					e.Use();
  881. 				}
  882. 				else if (e.keyCode == KeyCode.LeftArrow)
  883. 				{
  884. 					NGUIEditorTools.RegisterUndo("Nudge Rect", t);
  885. 					NGUIEditorTools.RegisterUndo("Nudge Rect", mWidget);
  886. 					NGUIMath.MoveRect(mWidget, -1f, 0f);
  887. 					e.Use();
  888. 				}
  889. 				else if (e.keyCode == KeyCode.RightArrow)
  890. 				{
  891. 					NGUIEditorTools.RegisterUndo("Nudge Rect", t);
  892. 					NGUIEditorTools.RegisterUndo("Nudge Rect", mWidget);
  893. 					NGUIMath.MoveRect(mWidget, 1f, 0f);
  894. 					e.Use();
  895. 				}
  896. 				else if (e.keyCode == KeyCode.Escape)
  897. 				{
  898. 					if (GUIUtility.hotControl == id)
  899. 					{
  900. 						if (mAction != Action.None)
  901. 							Undo.PerformUndo();
  903. 						GUIUtility.hotControl = 0;
  904. 						GUIUtility.keyboardControl = 0;
  906. 						mActionUnderMouse = Action.None;
  907. 						mAction = Action.None;
  908. 						e.Use();
  909. 					}
  910. 					else Selection.activeGameObject = null;
  911. 				}
  912. 			}
  913. 			break;
  914. 		}
  915. 	}
  917. 	/// <summary>
  918. 	/// Cache the reference.
  919. 	/// 记录引用
  920. 	/// </summary>
  922. 	protected override void OnEnable ()
  923. 	{
  924. 		base.OnEnable();
  925. 		instance = this;
  926. 		mWidget = target as UIWidget; // 在对 mWidget 进行操作时为什么不需要判空？
  927. 	}
  929. 	/// <summary>
  930. 	/// All widgets have depth, color and make pixel-perfect options
  931.     /// 所有组件都有 depth，color和 pixel-perfect 选项
  932. 	/// </summary>
  934.     protected override void DrawCustomProperties ()
  935. 	{
  936. 		if (NGUISettings.unifiedTransform) // 这个不知道是哪里设置的。。如果是统一的transform，某些部分就不需要显示了。
  937. 		{
  938. 			DrawColor(serializedObject, mWidget);
  939. 		}
  940. 		else DrawInspectorProperties(serializedObject, mWidget, true); // 在检视器中显示Widget组件的操作面板
  941. 	}
  943. 	/// <summary>
  944. 	/// Draw common widget properties that can be shown as a part of the Transform Inspector.
  945. 	/// 在检视器中显示通用的 widget 属性，不显示颜色部分
  946. 	/// </summary>
  948. 	public void DrawWidgetTransform () { DrawInspectorProperties(serializedObject, mWidget, false); }
  950. 	/// <summary>
  951. 	/// Draw the widget's color.
  952. 	/// 在检视器中显示，设置 widget 的颜色和透明度
  953. 	/// </summary>
  955. 	static public void DrawColor (SerializedObject so, UIWidget w)
  956. 	{
  957. 		if ((w.GetType() != typeof(UIWidget)))
  958. 		{
  959. 			NGUIEditorTools.DrawProperty("Color Tint", so, "mColor", GUILayout.MinWidth(20f));
  960. 		}
  961. 		else if (so.isEditingMultipleObjects)
  962. 		{
  963. 			NGUIEditorTools.DrawProperty("Alpha", so, "mColor.a", GUILayout.Width(120f));
  964. 		}
  965. 		else
  966. 		{
  967. 			GUI.changed = false;
  968. 			float alpha = EditorGUILayout.Slider("Alpha", w.alpha, 0f, 1f);
  970. 			if (GUI.changed)
  971. 			{
  972. 				NGUIEditorTools.RegisterUndo("Alpha change", w);
  973. 				w.alpha = alpha;
  974. 			}
  975. 		}
  976. 	}
  978. 	/// <summary>
  979. 	/// Draw common widget properties.
  980. 	/// 在检视器中显示通用 widget 属性
  981. 	/// </summary>
  983. 	static public void DrawInspectorProperties (SerializedObject so, UIWidget w, bool drawColor)
  984. 	{
  985. 		if (drawColor)
  986. 		{
  987. 			DrawColor(so, w);
  988. 			GUILayout.Space(3f);
  989. 		}
  991. 		PrefabType type = PrefabUtility.GetPrefabType(w.gameObject); // TODO 为什么要辨别出 prefab 的类型？有些情况不需要显示？
  993. 		if (NGUIEditorTools.DrawHeader("Widget")) // 包裹起来
  994. 		{
  995. 			NGUIEditorTools.BeginContents();
  996. 			if (NGUISettings.minimalisticLook) NGUIEditorTools.SetLabelWidth(70f);
  998. 			DrawPivot(so, w); //枢轴点
  999. 			DrawDepth(so, w, type == PrefabType.Prefab);// 深度
  1000. 			DrawDimensions(so, w, type == PrefabType.Prefab);// 大小
  1001. 			if (NGUISettings.minimalisticLook) NGUIEditorTools.SetLabelWidth(70f); 
  1003. 			SerializedProperty ratio = so.FindProperty("aspectRatio");
  1004. 			SerializedProperty aspect = so.FindProperty("keepAspectRatio");
  1006. 			GUILayout.BeginHorizontal();
  1007. 			{
  1008. 				if (!aspect.hasMultipleDifferentValues && aspect.intValue == 0) // 单个或多个对象选中时 aspect 都是第一种情况
  1009. 				{
  1010. 					EditorGUI.BeginDisabledGroup(true); // 设置为禁用
  1011. 					NGUIEditorTools.DrawProperty("Aspect", ratio, false, GUILayout.Width(130f));
  1012. 					EditorGUI.EndDisabledGroup();
  1013. 				}
  1014. 				else NGUIEditorTools.DrawProperty("Aspect", ratio, false, GUILayout.Width(130f));
  1016. 				NGUIEditorTools.DrawProperty("", aspect, false, GUILayout.MinWidth(20f));
  1017. 			}
  1018. 			GUILayout.EndHorizontal();
  1020.             // 编辑多个对象或者对象存在 碰撞盒的时候显示
  1021. 			if (so.isEditingMultipleObjects || w.hasBoxCollider)
  1022. 			{
  1023. 				GUILayout.BeginHorizontal();
  1024. 				{
  1025. 					NGUIEditorTools.DrawProperty("Collider", so, "autoResizeBoxCollider", GUILayout.Width(100f));
  1026. 					GUILayout.Label("auto-adjust to match");
  1027. 				}
  1028. 				GUILayout.EndHorizontal();
  1029. 			}
  1030. 			NGUIEditorTools.EndContents();
  1031. 		}
  1032. 	}
  1034. 	/// <summary>
  1035. 	/// Draw widget's dimensions.
  1036. 	/// </summary>
  1038. 	static void DrawDimensions (SerializedObject so, UIWidget w, bool isPrefab)
  1039. 	{
  1040. 		GUILayout.BeginHorizontal();
  1041. 		{
  1042. 			bool freezeSize = so.isEditingMultipleObjects;
  1044. 			UILabel lbl = w as UILabel;
  1046. 			if (!freezeSize && lbl) freezeSize = (lbl.overflowMethod == UILabel.Overflow.ResizeFreely);
  1048. 			if (freezeSize)
  1049. 			{
  1050. 				EditorGUI.BeginDisabledGroup(true);
  1051. 				NGUIEditorTools.DrawProperty("Size", so, "mWidth", GUILayout.MinWidth(100f));
  1052. 				EditorGUI.EndDisabledGroup();
  1053. 			}
  1054. 			else
  1055. 			{
  1056. 				GUI.changed = false;
  1057. 				int val = EditorGUILayout.IntField("Size", w.width, GUILayout.MinWidth(100f));
  1059. 				if (GUI.changed)
  1060. 				{
  1061. 					NGUIEditorTools.RegisterUndo("Dimensions Change", w);
  1062. 					w.width = val;
  1063. 				}
  1064. 			}
  1066. 			if (!freezeSize && lbl)
  1067. 			{
  1068. 				UILabel.Overflow ov = lbl.overflowMethod;
  1069. 				freezeSize = (ov == UILabel.Overflow.ResizeFreely || ov == UILabel.Overflow.ResizeHeight);
  1070. 			}
  1072. 			NGUIEditorTools.SetLabelWidth(12f);
  1074. 			if (freezeSize)
  1075. 			{
  1076. 				EditorGUI.BeginDisabledGroup(true);
  1077. 				NGUIEditorTools.DrawProperty("x", so, "mHeight", GUILayout.MinWidth(30f));
  1078. 				EditorGUI.EndDisabledGroup();
  1079. 			}
  1080. 			else
  1081. 			{
  1082. 				GUI.changed = false;
  1083. 				int val = EditorGUILayout.IntField("x", w.height, GUILayout.MinWidth(30f));
  1085. 				if (GUI.changed)
  1086. 				{
  1087. 					NGUIEditorTools.RegisterUndo("Dimensions Change", w);
  1088. 					w.height = val;
  1089. 				}
  1090. 			}
  1092. 			NGUIEditorTools.SetLabelWidth(80f);
  1094. 			if (isPrefab)
  1095. 			{
  1096. 				GUILayout.Space(70f);
  1097. 			}
  1098. 			else
  1099. 			{
  1100. 				EditorGUI.BeginDisabledGroup(so.isEditingMultipleObjects);
  1102. 				if (GUILayout.Button("Snap", GUILayout.Width(60f)))
  1103. 				{
  1104. 					foreach (GameObject go in Selection.gameObjects)
  1105. 					{
  1106. 						UIWidget pw = go.GetComponent<UIWidget>();
  1108. 						if (pw != null)
  1109. 						{
  1110. 							NGUIEditorTools.RegisterUndo("Snap Dimensions", pw);
  1111. 							NGUIEditorTools.RegisterUndo("Snap Dimensions", pw.transform);
  1112. 							pw.MakePixelPerfect();
  1113. 						}
  1114. 					}
  1115. 				}
  1116. 				EditorGUI.EndDisabledGroup();
  1117. 			}
  1118. 		}
  1119. 		GUILayout.EndHorizontal();
  1120. 	}
  1122. 	/// <summary>
  1123. 	/// Draw widget's depth.
  1124. 	/// </summary>
  1126. 	static void DrawDepth (SerializedObject so, UIWidget w, bool isPrefab)
  1127. 	{
  1128. 		if (isPrefab) return;
  1130. 		GUILayout.Space(2f);
  1131. 		GUILayout.BeginHorizontal();
  1132. 		{
  1133. 			EditorGUILayout.PrefixLabel("Depth");
  1135. 			if (GUILayout.Button("Back", GUILayout.MinWidth(46f)))
  1136. 			{
  1137. 				foreach (GameObject go in Selection.gameObjects)
  1138. 				{
  1139. 					UIWidget pw = go.GetComponent<UIWidget>();
  1140. 					if (pw != null) pw.depth = w.depth - 1;
  1141. 				}
  1142. 			}
  1144. 			NGUIEditorTools.DrawProperty("", so, "mDepth", GUILayout.MinWidth(20f));
  1146. 			if (GUILayout.Button("Forward", GUILayout.MinWidth(60f)))
  1147. 			{
  1148. 				foreach (GameObject go in Selection.gameObjects)
  1149. 				{
  1150. 					UIWidget pw = go.GetComponent<UIWidget>();
  1151. 					if (pw != null) pw.depth = w.depth + 1;
  1152. 				}
  1153. 			}
  1154. 		}
  1155. 		GUILayout.EndHorizontal();
  1157. 		int matchingDepths = 1;
  1159. 		UIPanel p = w.panel;
  1161. 		if (p != null)
  1162. 		{
  1163. 			for (int i = 0, imax = p.widgets.Count; i < imax; ++i)
  1164. 			{
  1165. 				UIWidget pw = p.widgets[i];
  1166. 				if (pw != w && pw.depth == w.depth)
  1167. 					++matchingDepths;
  1168. 			}
  1169. 		}
  1171. 		if (matchingDepths > 1)
  1172. 		{
  1173. 			EditorGUILayout.HelpBox(matchingDepths + " widgets are sharing the depth value of " + w.depth, MessageType.Info);
  1174. 		}
  1175. 	}
  1177. 	/// <summary>
  1178. 	/// Draw the widget's pivot.
  1179. 	/// </summary>
  1181. 	static void DrawPivot (SerializedObject so, UIWidget w)
  1182. 	{
  1183. 		SerializedProperty pv = so.FindProperty("mPivot");
  1185. 		if (pv.hasMultipleDifferentValues)
  1186. 		{
  1187. 			// TODO: Doing this doesn't keep the widget's position where it was. Another approach is needed.
  1188. 			NGUIEditorTools.DrawProperty("Pivot", so, "mPivot");
  1189. 		}
  1190. 		else
  1191. 		{
  1192. 			// Pivot point -- the new, more visual style
  1193. 			GUILayout.BeginHorizontal();
  1194. 			GUILayout.Label("Pivot", GUILayout.Width(NGUISettings.minimalisticLook ? 66f : 76f));
  1195. 			Toggle(w, "\u25C4", "ButtonLeft", UIWidget.Pivot.Left, true);
  1196. 			Toggle(w, "\u25AC", "ButtonMid", UIWidget.Pivot.Center, true);
  1197. 			Toggle(w, "\u25BA", "ButtonRight", UIWidget.Pivot.Right, true);
  1198. 			Toggle(w, "\u25B2", "ButtonLeft", UIWidget.Pivot.Top, false);
  1199. 			Toggle(w, "\u258C", "ButtonMid", UIWidget.Pivot.Center, false);
  1200. 			Toggle(w, "\u25BC", "ButtonRight", UIWidget.Pivot.Bottom, false);
  1202. 			GUILayout.EndHorizontal();
  1203. 			pv.enumValueIndex = (int)w.pivot;
  1204. 		}
  1205. 	}
  1207. 	/// <summary>
  1208. 	/// Draw a toggle button for the pivot point.
  1209. 	/// </summary>
  1211. 	static void Toggle (UIWidget w, string text, string style, UIWidget.Pivot pivot, bool isHorizontal)
  1212. 	{
  1213. 		bool isActive = false;
  1215. 		switch (pivot)
  1216. 		{
  1217. 			case UIWidget.Pivot.Left:
  1218. 			isActive = IsLeft(w.pivot);
  1219. 			break;
  1221. 			case UIWidget.Pivot.Right:
  1222. 			isActive = IsRight(w.pivot);
  1223. 			break;
  1225. 			case UIWidget.Pivot.Top:
  1226. 			isActive = IsTop(w.pivot);
  1227. 			break;
  1229. 			case UIWidget.Pivot.Bottom:
  1230. 			isActive = IsBottom(w.pivot);
  1231. 			break;
  1233. 			case UIWidget.Pivot.Center:
  1234. 			isActive = isHorizontal ? pivot == GetHorizontal(w.pivot) : pivot == GetVertical(w.pivot);
  1235. 			break;
  1236. 		}
  1238. 		if (GUILayout.Toggle(isActive, text, style) != isActive)
  1239. 			SetPivot(w, pivot, isHorizontal);
  1240. 	}
  1242. 	static bool IsLeft (UIWidget.Pivot pivot)
  1243. 	{
  1244. 		return pivot == UIWidget.Pivot.Left ||
  1245. 			pivot == UIWidget.Pivot.TopLeft ||
  1246. 			pivot == UIWidget.Pivot.BottomLeft;
  1247. 	}
  1249. 	static bool IsRight (UIWidget.Pivot pivot)
  1250. 	{
  1251. 		return pivot == UIWidget.Pivot.Right ||
  1252. 			pivot == UIWidget.Pivot.TopRight ||
  1253. 			pivot == UIWidget.Pivot.BottomRight;
  1254. 	}
  1256. 	static bool IsTop (UIWidget.Pivot pivot)
  1257. 	{
  1258. 		return pivot == UIWidget.Pivot.Top ||
  1259. 			pivot == UIWidget.Pivot.TopLeft ||
  1260. 			pivot == UIWidget.Pivot.TopRight;
  1261. 	}
  1263. 	static bool IsBottom (UIWidget.Pivot pivot)
  1264. 	{
  1265. 		return pivot == UIWidget.Pivot.Bottom ||
  1266. 			pivot == UIWidget.Pivot.BottomLeft ||
  1267. 			pivot == UIWidget.Pivot.BottomRight;
  1268. 	}
  1270. 	static UIWidget.Pivot GetHorizontal (UIWidget.Pivot pivot)
  1271. 	{
  1272. 		if (IsLeft(pivot)) return UIWidget.Pivot.Left;
  1273. 		if (IsRight(pivot)) return UIWidget.Pivot.Right;
  1274. 		return UIWidget.Pivot.Center;
  1275. 	}
  1277. 	static UIWidget.Pivot GetVertical (UIWidget.Pivot pivot)
  1278. 	{
  1279. 		if (IsTop(pivot)) return UIWidget.Pivot.Top;
  1280. 		if (IsBottom(pivot)) return UIWidget.Pivot.Bottom;
  1281. 		return UIWidget.Pivot.Center;
  1282. 	}
  1284. 	static UIWidget.Pivot Combine (UIWidget.Pivot horizontal, UIWidget.Pivot vertical)
  1285. 	{
  1286. 		if (horizontal == UIWidget.Pivot.Left)
  1287. 		{
  1288. 			if (vertical == UIWidget.Pivot.Top) return UIWidget.Pivot.TopLeft;
  1289. 			if (vertical == UIWidget.Pivot.Bottom) return UIWidget.Pivot.BottomLeft;
  1290. 			return UIWidget.Pivot.Left;
  1291. 		}
  1293. 		if (horizontal == UIWidget.Pivot.Right)
  1294. 		{
  1295. 			if (vertical == UIWidget.Pivot.Top) return UIWidget.Pivot.TopRight;
  1296. 			if (vertical == UIWidget.Pivot.Bottom) return UIWidget.Pivot.BottomRight;
  1297. 			return UIWidget.Pivot.Right;
  1298. 		}
  1299. 		return vertical;
  1300. 	}
  1302. 	static void SetPivot (UIWidget w, UIWidget.Pivot pivot, bool isHorizontal)
  1303. 	{
  1304. 		UIWidget.Pivot horizontal = GetHorizontal(w.pivot);
  1305. 		UIWidget.Pivot vertical = GetVertical(w.pivot);
  1307. 		pivot = isHorizontal ? Combine(pivot, vertical) : Combine(horizontal, pivot);
  1309. 		if (w.pivot != pivot)
  1310. 		{
  1311. 			NGUIEditorTools.RegisterUndo("Pivot change", w);
  1312. 			w.pivot = pivot;
  1313. 		}
  1314. 	}
  1316. 	protected override void OnDrawFinalProperties ()
  1317. 	{
  1318. 		if (mAnchorType == AnchorType.Advanced || !mWidget.isAnchored) return;
  1320. 		SerializedProperty sp = serializedObject.FindProperty("leftAnchor.target");
  1322. 		if (!IsRect(sp))
  1323. 		{
  1324. 			GUILayout.Space(3f);
  1325. 			GUILayout.BeginHorizontal();
  1326. 			GUILayout.Space(6f);
  1327. 			NGUIEditorTools.DrawProperty("", serializedObject, "hideIfOffScreen", GUILayout.Width(18f));
  1328. 			GUILayout.Label("Hide if off-screen", GUILayout.MinWidth(20f));
  1329. 			GUILayout.EndHorizontal();
  1330. 		}
  1331. 	}
  1332. }

NGUI 源码分析- UIWidgetInspector的更多相关文章

  1. NGUI 源码分析- AnchorPoint

    AnchorPoint 是 UIRect 的一个内部类,此处规定作为基准的那个对象称为锚点对象,基准对象对应的矩形框称为目标框,当前对象对应的矩形框称为源框. public class AnchorP ...

  2. ABP源码分析一：整体项目结构及目录

    ABP是一套非常优秀的web应用程序架构,适合用来搭建集中式架构的web应用程序. 整个Abp的Infrastructure是以Abp这个package为核心模块(core)+15个模块(module ...

  3. HashMap与TreeMap源码分析

    1. 引言     在红黑树--算法导论(15)中学习了红黑树的原理.本来打算自己来试着实现一下,然而在看了JDK(1.8.0)TreeMap的源码后恍然发现原来它就是利用红黑树实现的(很惭愧学了Ja ...

  4. nginx源码分析之网络初始化

    nginx作为一个高性能的HTTP服务器,网络的处理是其核心,了解网络的初始化有助于加深对nginx网络处理的了解,本文主要通过nginx的源代码来分析其网络初始化. 从配置文件中读取初始化信息 与网 ...

  5. zookeeper源码分析之五服务端(集群leader)处理请求流程

    leader的实现类为LeaderZooKeeperServer,它间接继承自标准ZookeeperServer.它规定了请求到达leader时需要经历的路径: PrepRequestProcesso ...

  6. zookeeper源码分析之四服务端(单机)处理请求流程

    上文: zookeeper源码分析之一服务端启动过程 中,我们介绍了zookeeper服务器的启动过程,其中单机是ZookeeperServer启动,集群使用QuorumPeer启动,那么这次我们分析 ...

  7. zookeeper源码分析之三客户端发送请求流程

    znode 可以被监控,包括这个目录节点中存储的数据的修改,子节点目录的变化等,一旦变化可以通知设置监控的客户端,这个功能是zookeeper对于应用最重要的特性,通过这个特性可以实现的功能包括配置的 ...

  8. java使用websocket，并且获取HttpSession，源码分析

    转载请在页首注明作者与出处 http://www.cnblogs.com/zhuxiaojie/p/6238826.html 一:本文使用范围 此文不仅仅局限于spring boot,普通的sprin ...

  9. ABP源码分析二：ABP中配置的注册和初始化

    一般来说,ASP.NET Web应用程序的第一个执行的方法是Global.asax下定义的Start方法.执行这个方法前HttpApplication 实例必须存在,也就是说其构造函数的执行必然是完成 ...

随机推荐

  1. [ch04-01] 用最小二乘法解决线性回归问题

    系列博客,原文在笔者所维护的github上:https://aka.ms/beginnerAI, 点击star加星不要吝啬,星越多笔者越努力. 4.1 最小二乘法 4.1.1 历史 最小二乘法,也叫做 ...

  2. Caused by: java.util.zip.ZipException: zip file is empty

    1.问题描述:mybranch分支代码和master分支的代码一模一样,mybranch代码部署到服务器上没有任何问题,而master代码部署到服务器上运行不起来. 2.解决办法: (1)登陆服务器启 ...

  3. Linux进阶文档丨阿里架构师十年Linux心得，全在这份文档里面

    Linux是什么 Linux就是个操作系统: 它和Windows XP.Windows 7.Windows 10什么的一样就是一个操作系统而已! Linux能干什么: 它能当服务器,服务器上安装者各种 ...

  4. SpringBoot源码学习系列之嵌入式Servlet容器

    目录 1.博客前言简单介绍 2.定制servlet容器 3.变换servlet容器 4.servlet容器启动原理 SpringBoot源码学习系列之嵌入式Servlet容器启动原理 @ 1.博客前言 ...

  5. 十一次作业——LL(1)文法的判断，递归下降分析程序

    1. 文法 G(S): (1)S -> AB (2)A ->Da|ε (3)B -> cC (4)C -> aADC |ε (5)D -> b|ε 验证文法 G(S)是不 ...

  6. css重置样式

    <style> html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, ...

  7. Dict.setdefault()

    """ setdefault方法参数输入已有键,返回对应值,找不到已有键,创建新键,值为None """ >>> dict ...

  8. windows下利用iis建立网站网站并实现局域共享

    博客园 首页 新随笔 联系 管理 订阅 随笔- 54  文章- 9  评论- 0  Windows下利用IIS建立网站并实现局域网共享 https://blog.csdn.net/qq_4148541 ...

  9. luogu P1044 栈

    题目背景 栈是计算机中经典的数据结构,简单的说,栈就是限制在一端进行插入删除操作的线性表. 栈有两种最重要的操作,即poppop(从栈顶弹出一个元素)和pushpush(将一个元素进栈). 栈的重要性 ...

  10. [TimLinux] JavaScript 元素动态显示

    1. css的opacity属性 这个属性用于:设置元素的不透明级别,取值范围:从 0.0 (完全透明)到 1.0(完全不透明),元素所在的文本流还在.这个属性的动态变化可以用来设置元素的淡入淡出效果 ...