void Awake()
	{
        _uiItem = this.GetSafeComponent<UIRect>();

        float w = Screen.width ;
        float h = Screen.height;

	    float res = h/w;
        //Debug.LogWarning(res);

	    if (res > 1.55) //16:10
	    {
            _uiItem.leftAnchor.Set(0f, 32f);
            _uiItem.rightAnchor.Set(0f, 284f);
            _uiItem.bottomAnchor.Set(0.5f, -126f);
            _uiItem.topAnchor.Set(0.5f, 126f);
	    }

        //228
        if (res > 1.45 && res < 1.55) //3:2
        {
            _uiItem.leftAnchor.Set(0f, 32f);
            _uiItem.rightAnchor.Set(0f, 260f);
            _uiItem.bottomAnchor.Set(0.5f, -114f);
            _uiItem.topAnchor.Set(0.5f, 114f);
        }

        //не нужно
        //if (res < 1.45) //4:3
	}

 /// <summary>
 /// Constructs a UIElement with selected and unselected states 
 /// param rect[] takes an array of UIRect dimentions for drawing of all options
 /// param path[] takes an array of path names to load appropriate assets from Resources
 /// param selected specifies whether the element is in selected or unselected state
 /// </param>
 public UICheckButton(UIRect rect, bool selected, string[] path)
 {
     this.mRect = rect;
     mSelected = selected;
     mStyle = new GUIStyle();
     mStyle.normal.background = Resources.Load(path[0]) as Texture2D;
     mStyle.active.background = Resources.Load(path[1]) as Texture2D;
     mStyle.onNormal.background = Resources.Load(path[1]) as Texture2D;
 }

    private void SetToTarget()
    {
        var uiCamera = transform.root.GetComponentInChildren<Camera>();

        _uiItem = this.GetSafeComponent<UIRect>();
        Vector3 offset = new Vector3(0, _yOffset, 0);
        Vector3 pos = uiCamera.ScreenToWorldPoint(Camera.main.WorldToScreenPoint(_bottomMarker.position + offset));
        _uiItem.transform.position = pos;
        _uiItem.transform.SetLocalZ(0);
    }

    private void Start()
    {
        
        _uiItem = this.GetSafeComponent<UIRect>();
        _uiItem.enabled = false;

        EventMessenger.Subscribe(GameEvent.OnTutorialCompleteShowText, this, () => Invoke("ShowSprite", _clickInterval));
        EventMessenger.Subscribe(GameEvent.OnTutorial_ClickByTarget, this, () => Invoke("MoveToButtonStart", 0f));

        Invoke("SetStartPos", 2f);
    }

	void Cache ()
	{
		mCached = true;
		mRect = GetComponent<UIRect>();

		if (mRect == null)
		{
			Renderer ren = GetComponent<Renderer>();
			if (ren != null) mMat = ren.material;
			if (mMat == null) mRect = GetComponentInChildren<UIRect>();
		}
	}

	void Start ()
	{
        _uiItem = this.GetSafeComponent<UIRect>();

        //float w = Screen.width ;
        //float h = Screen.height;

	    //float res = h/w;
        //Debug.LogWarning(res);

        _uiItem.leftAnchor.target = _uiItem.rightAnchor.target = transform.root.Find("Panel1");

	    _uiItem.leftAnchor.Set(0f, 0f);
	    _uiItem.rightAnchor.Set(1f, 0f);

        _uiItem.ResetAnchors();
	}

 /// <summary>
 /// Constructs a UIElement with series of options to choose from; 
 /// Only one option is selected at a time. param index specifies which option is set to true
 /// param rect[] takes an array of UIRect dimentions for drawing of all options
 /// param path[,] takes an array of path names to load appropriate assets from Resources
 /// </param>
 public UIRadioButton(UIRect[] rect, int index, string[,] path)
 {
     if(index > rect.Length)
     {
         return; 
     }
     
     this.mRect = rect;
     mStyle = new GUIStyle[rect.Length];
     
     for(int i = 0; i < mStyle.Length; i++)
     {
         mStyle[i] = new GUIStyle();
         mStyle[i].normal.background = Resources.Load(path[i,0]) as Texture2D;
         mStyle[i].active.background = Resources.Load(path[i,1]) as Texture2D;
         mStyle[i].onNormal.background = Resources.Load(path[i,1]) as Texture2D;
     }
 
     mOptionsTapped = new bool[rect.Length];
     mOptionsSelected = new bool[rect.Length];
     
     mOptionsSelected[index] = true;
 }

 /// <summary>
 /// Initializes a new instance for label
 /// <param name='rect'> specifies label size
 /// <param name='path'> specifies path for assets to load from Resources
 public UILabel(UIRect rect, string path)
 {
     this.mRect = rect;
     mStyle = new GUIStyle();
     mStyle.normal.background = Resources.Load(path) as Texture2D;
 }

	void Awake () { mRect = GetComponent<UIRect>(); }

	/// <summary>
	/// Returns whether the specified widget is visible by the panel.
	/// </summary>

	public bool IsVisible (UIRect w)
	{
		Vector3[] corners = w.worldCorners;
		return IsVisible(corners[0], corners[1], corners[2], corners[3]);
	}

 public virtual void ParentHasChanged()
 {
     this.mParentFound = false;
     UIRect y = NGUITools.FindInParents<UIRect>(this.cachedTransform.parent);
     if (this.mParent != y)
     {
         if (this.mParent)
         {
             this.mParent.mChildren.Remove(this);
         }
         this.mParent = y;
         if (this.mParent)
         {
             this.mParent.mChildren.Add(this);
         }
         this.mRootSet = false;
     }
 }

        void Awake()
        {
            // This will allow to set the view in the inspector if we want to
            ViewRoot = ViewRoot ?? GetComponent<UIRect>();

            // Set the alpha to cero so the item is created
            // invisible. When the show method is called
            // the view will be made visible using a transition.
            #if UNITY_EDITOR
            if (UnityEditor.EditorApplication.isPlaying)
                UpdateAlpha(0);
            #else
            ViewRoot.alpha = 0f;
            #endif

            AwakeUnityMsg();
        }

	/// <summary>
	/// Adjust the rectangle's position using the specified local delta coordinates.
	/// </summary>

	static public void MoveRect (UIRect rect, float x, float y)
	{
		int ix = Mathf.FloorToInt(x + 0.5f);
		int iy = Mathf.FloorToInt(y + 0.5f);

		Transform t = rect.cachedTransform;
		t.localPosition += new Vector3(ix, iy);
		int anchorCount = 0;

		if (rect.leftAnchor.target)
		{
			++anchorCount;
			rect.leftAnchor.absolute += ix;
		}

		if (rect.rightAnchor.target)
		{
			++anchorCount;
			rect.rightAnchor.absolute += ix;
		}

		if (rect.bottomAnchor.target)
		{
			++anchorCount;
			rect.bottomAnchor.absolute += iy;
		}

		if (rect.topAnchor.target)
		{
			++anchorCount;
			rect.topAnchor.absolute += iy;
		}

#if UNITY_EDITOR
		NGUITools.SetDirty(rect);
#endif

		// If all sides were anchored, we're done
		if (anchorCount != 0) rect.UpdateAnchors();
	}

	/// <summary>
	/// Call this function when the rectangle's parent has changed.
	/// </summary>

	public virtual void ParentHasChanged ()
	{
		mParentFound = false;
		UIRect pt = NGUITools.FindInParents<UIRect>(cachedTransform.parent);

		if (mParent != pt)
		{
			if (mParent) mParent.mChildren.Remove(this);
			mParent = pt;
			if (mParent) mParent.mChildren.Add(this);
			mRootSet = false;
		}
	}

 private void Awake()
 {
     this.mRect = base.GetComponent<UIRect>();
 }

 private void FindCameraFor(UIRect.AnchorPoint ap)
 {
     if (ap.target == null || ap.rect != null)
     {
         ap.targetCam = null;
     }
     else
     {
         ap.targetCam = NGUITools.FindCameraForLayer(ap.target.gameObject.layer);
     }
 }

 protected Vector3 GetLocalPos(UIRect.AnchorPoint ac, Transform trans)
 {
     if (this.anchorCamera == null || ac.targetCam == null)
     {
         return this.cachedTransform.localPosition;
     }
     Rect rect = ac.targetCam.rect;
     Vector3 vector = ac.targetCam.WorldToViewportPoint(ac.target.position);
     Vector3 vector2 = new Vector3(vector.x * rect.width + rect.x, vector.y * rect.height + rect.y, vector.z);
     vector2 = this.mCam.ViewportToWorldPoint(vector2);
     if (trans != null)
     {
         vector2 = trans.InverseTransformPoint(vector2);
     }
     vector2.x = Mathf.Floor(vector2.x + 0.5f);
     vector2.y = Mathf.Floor(vector2.y + 0.5f);
     return vector2;
 }

 public static void MoveWidget(UIRect w, float x, float y)
 {
     NGUIMath.MoveRect(w, x, y);
 }

	/// <summary>
	/// Draw the specified anchor point.
	/// </summary>

	static public void DrawAnchorHandle (UIRect.AnchorPoint anchor, Transform myTrans, Vector3[] myCorners, int side, int id)
	{
		if (!anchor.target) return;

		int i0, i1;

		if (side == 0)
		{
			// Left
			i0 = 0;
			i1 = 1;
		}
		else if (side == 1)
		{
			// Top
			i0 = 1;
			i1 = 2;
		}
		else if (side == 2)
		{
			// Right
			i0 = 3;
			i1 = 2;
		}
		else
		{
			// Bottom
			i0 = 0;
			i1 = 3;
		}

		Vector3 myPos = (myCorners[i0] + myCorners[i1]) * 0.5f;
		Vector3[] sides = null;

		if (anchor.rect != null)
		{
			sides = anchor.rect.worldCorners;
		}
		else if (anchor.target.GetComponent<Camera>() != null)
		{
			sides = anchor.target.GetComponent<Camera>().GetWorldCorners();
		}

		Vector3 theirPos;

		if (sides != null)
		{
			Vector3 v0, v1;

			if (side == 0 || side == 2)
			{
				// Left or right
				v0 = Vector3.Lerp(sides[0], sides[3], anchor.relative);
				v1 = Vector3.Lerp(sides[1], sides[2], anchor.relative);
			}
			else
			{
				// Top or bottom
				v0 = Vector3.Lerp(sides[0], sides[1], anchor.relative);
				v1 = Vector3.Lerp(sides[3], sides[2], anchor.relative);
			}

			theirPos = HandleUtility.ProjectPointLine(myPos, v0, v1);
		}
		else
		{
			theirPos = anchor.target.position;
		}

		NGUIHandles.DrawShadowedLine(myCorners, myPos, theirPos, Color.yellow);

		if (Event.current.GetTypeForControl(id) == EventType.Repaint)
		{
			Vector2 screenPoint = HandleUtility.WorldToGUIPoint(theirPos);
			Rect rect = new Rect(screenPoint.x - 7f, screenPoint.y - 7f, 14f, 14f);
			if (mYellowDot == null) mYellowDot = "sv_label_4";

			Vector3 v0 = HandleUtility.WorldToGUIPoint(myPos);
			Vector3 v1 = HandleUtility.WorldToGUIPoint(theirPos);

			Handles.BeginGUI();
				
			mYellowDot.Draw(rect, GUIContent.none, id);

			Vector3 diff = v1 - v0;
			bool isHorizontal = Mathf.Abs(diff.x) > Mathf.Abs(diff.y);
			float mag = diff.magnitude;

			if ((isHorizontal && mag > 60f) || (!isHorizontal && mag > 30f))
			{
				Vector3 pos = (myPos + theirPos) * 0.5f;
				string text = anchor.absolute.ToString();

				GUI.color = Color.yellow;

				if (side == 0)
//.........这里部分代码省略.........

	void Awake () { 
        mRect = GetComponent<UIRect>();
        orignFrom = from;
        orignTo = to;
    }