private void Start()
        {
            gridRect = GetComponentInParent<RectTransform>();
            gridCanvas = GetComponentInParent<Canvas>();
            gridLayout = GetComponentInParent<GridLayoutGroup>();

            gridRect.pivot = new Vector2(0, 0);
            gridRect.position = new Vector3(terrainMesh.transform.position.x, 6.0f, terrainMesh.transform.position.z);
            gridRect.anchorMin = new Vector2(terrainMesh.transform.position.x, terrainMesh.transform.position.z);
            gridRect.anchorMax = new Vector2(terrainMesh.terrainData.size.x, terrainMesh.terrainData.size.z);

            gridLayout.CalculateLayoutInputHorizontal();

            Debug.Log(string.Format("Origin: {0}, Size: {1}, Cell size: {2}\n", gridRect.position.ToString(), gridRect.rect.size.ToString(), gridLayout.cellSize));

            buttonTemplate = GetComponentInChildren<Button>();
            for (int y = 0; y < gridRect.rect.y; y++)
            {
                for (int x = 0; x < gridRect.rect.x; x++)
                {
                    Vector3 pos = new Vector3(x, 0, y); // * spacing;
                    Button b = (Button)Instantiate(buttonTemplate, pos, Quaternion.identity);
                    //b.gameObject.AddComponent<LayoutElement>();

                    //b.name = "Button " + x.ToString() + "," + y.ToString();
                    //b.GetComponentInChildren<Text>().text = b.name;
                    gridLayout.SetLayoutHorizontal();
                }
            }
        }

        void Start()
        {
            timerText = GameObject.Find("Play Timer").GetComponent<Text>();
            canvas = this.GetComponent<Canvas>();

            canvas.enabled = true;
        }

 protected override void OnEnable()
 {
     base.OnEnable ();
     current = this;
     canvas = GetComponentInParent<Canvas> ();
     base.Close ();
 }

 void Start()
 {
     quitMenu = quitMenu.GetComponent<Canvas>();
     quitMenu.enabled = false;
     startText = startText.GetComponent<Button>();
     exitText = exitText.GetComponent<Button>();
 }

        internal void init()
        {
            var cardCanvas = GameObject.Find(Constants.cardCanvas);
            canvas = GameObject.Find("Canvas").gameObject.GetComponent<Canvas>();
            //set up fake card model
            var hoverCardModel = new CardModel()
            {
                playerId = -1,
            };

            //init the hover card that's hidden most of the time
            cardService.CreateCard(hoverCardModel, cardCanvas.transform, new Vector3(10000,10000, 0));
            var hoverCardGO = hoverCardModel.gameObject;

            hoverCardGO.name = hoverName;
            hoverCardGO.tag = "HoverCard";

            //disable all colliders so you can't hover the hover
            foreach (var collider in hoverCardGO.GetComponentsInChildren<BoxCollider>())
            {
                collider.enabled = false;
            }
            foreach (var collider in hoverCardGO.GetComponentsInChildren<MeshCollider>())
            {
                collider.enabled = false;
            }

            hoverCardView = hoverCardGO.AddComponent<CardView>();
            hoverCardView.card = hoverCardModel;

            hoverCardGO.SetActive(false);
        }

    void Update() {
        if (followObject != null) {
            if (!Application.isPlaying || canvas == null) {
                canvas = GetComponentInParent<Canvas>();
                if (canvas == null) {
                    Debug.LogError("This object should be placed under a canvas", this);
                }
            }

            if (!Application.isPlaying || cameraReference == null) {
                cameraReference = worldCamera.Lookup<Camera>(this);
            }
            UpdateFollowObject();

            bool visible = IsPossiblyVisible();
            var energyBarBase = GetComponent<EnergyBarBase>();

            energyBarBase.opacity = visible ? 1 : 0;

            if (cameraReference != null && canvas != null) {
                if (canvas.renderMode == RenderMode.WorldSpace) {
                    energyBarBase.transform.rotation =
                        Quaternion.LookRotation(energyBarBase.transform.position - cameraReference.transform.position);
                } else {
                    energyBarBase.transform.rotation = Quaternion.identity;
                }
            }
        } else {
			FastPoolManager.GetPool(this.gameObject,false).FastDestroy(this.gameObject);
		}
    }

        public CreateAccountCanvasController(IoCResolver resolver, Canvas canvasView)
            : base(resolver, canvasView)
        {
            // resolve
            resolver.Resolve(out _messager);
            resolver.Resolve(out _user);

            ResolveElement(out _usernameInputField, "username_input_field");
            ResolveElement(out _passwordInputField, "password_input_field");
            ResolveElement(out _passwordConfirmationInputField, "password_confirmation_input_field");
            ResolveElement(out _confirmButton, "confirm_button");
            ResolveElement(out _backButton, "back_button");

            // initialize
            ShowCanvas = false;

            _usernameInputField.text = "";
            _passwordInputField.text = "";

            // subscribe
            _onCreateAccountSelected = _messager.Subscribe<CreateAccountSelectedMessage>(message =>
            {
                ShowCanvas = true;
                _currentAccountCreationSession = message;

                _usernameInputField.text = "";
                _passwordInputField.text = "";

                _confirmButton.onClick.RemoveAllListeners();
                _backButton.onClick.RemoveAllListeners();

                _confirmButton.onClick.AddListener(RegisterAccount);
                _backButton.onClick.AddListener(() => message.OnCancelled());
            });
        }

        private void InitializeMainComponents()
        {
            canvas = Instantiate(Resources.Load<Canvas>("Prefabs/Play/Canvas"));
            mainCamera = Instantiate(Resources.Load<Camera>("Prefabs/Play/MainCamera"));

            Canvas = canvas;
        }

        void Start()
        {
            timerBar = GameObject.Find("Card Selection Timer").transform;
            canvas = this.GetComponent<Canvas>();

            canvas.enabled = false;
        }

 /// <summary>
 /// 
 /// <para>
 /// Deregister the given Graphic from a Canvas.
 /// </para>
 /// 
 /// </summary>
 /// <param name="c">Canvas.</param><param name="graphic">Graphic to deregister.</param>
 public static void UnregisterGraphicForCanvas(Canvas c, Graphic graphic)
 {
   IndexedSet<Graphic> indexedSet;
   if ((Object) c == (Object) null || !GraphicRegistry.instance.m_Graphics.TryGetValue(c, out indexedSet))
     return;
   indexedSet.Remove(graphic);
 }

		public void OnHover(RectTransform uiElement) {
			
			this.uiElement = uiElement;

			if (this.tempHud != null) this.tempHud.enabled = false;

			if (this.animationRoot != null) this.animationRoot.SetInState();

			var canvas = uiElement.root.GetComponentsInChildren<Canvas>()[0];
			uiElement.root.GetComponentInChildren<Canvas>();
			this.uiElementCanvas = canvas;

			this.ApplyPosition();

			if (this.animationRoot != null) this.animationRoot.SetResetState();

			if (this.layoutRoot != null) {

				this.CheckPivot(uiElement.rect.size, canvas.transform as RectTransform);

			} else {
				
				var anchor = this.root.anchoredPosition3D;
				anchor.z = 0f;
				this.root.anchoredPosition3D = anchor + Vector3.up * uiElement.rect.size.y * 0.5f;

			}

		}

		public static Vector2 ScreenPoint(Camera mainCamera, Vector3 worldPosition, RectTransform parent, Canvas canvas)
		{
			var screenPosition = mainCamera.WorldToScreenPoint(worldPosition);
			var localPosition = Vector2.zero;
			RectTransformUtility.ScreenPointToLocalPointInRectangle(parent, screenPosition, canvas.worldCamera, out localPosition);
			return localPosition;
		}

 public void Awake()
 {
     GameManager.Instance.CursorEnabled = false;
     this.canvas = GetComponent<Canvas>();
     this.eventSystem = FindObjectOfType<EventSystem>();
     this.wasCancelPressed = false;
 }

		public override void OnEnter()
		{
			GameObject go = Fsm.GetOwnerDefaultTarget(gameObject);
			if (go != null)
			{
				_rt = go.GetComponent<RectTransform>();
			}
			
			GameObject goCanvas = canvas.Value;
			if (goCanvas != null)
			{
				_canvas = goCanvas.GetComponent<Canvas>();
			}

			if (_canvas==null && go!=null)
			{
				var _ui = go.GetComponent<UnityEngine.UI.Graphic>();
				if (_ui!=null)
				{
					_canvas = _ui.canvas;
				}
			}
			
			DoAction();
			
			if (!everyFrame)
			{
				Finish();
			}		
		}

        public MainMenuCanvasController(IoCResolver resolver, Canvas canvasView)
            : base(resolver, canvasView)
        {
            // resolve
            resolver.Resolve(out _messager);
            resolver.Resolve(out _user);

            ResolveElement(out _welcomeText, "welcome_text");
            ResolveElement(out _hostGameButton, "host_game_button");
            ResolveElement(out _joinGameButton, "join_game_button");
            ResolveElement(out _exitGameButton, "exit_game_button");

            // initialize
            ShowCanvas = false;

            _hostGameButton.onClick.AddListener(() =>
            {
                _messager.Publish(new HostGameClickedMessage());
            });

            _exitGameButton.onClick.AddListener(() =>
            {
                _messager.Publish(new ExitMessage());
            });

            // subscribe
            _onMainMenuSelected = _messager.Subscribe<MainMenuSelectedMessage>(message =>
            {
                ShowCanvas = true;
                _welcomeText.text = String.Format(LanguageStrings.MainMenuWelcome, _user.Username);
            });
        }

        protected override void Start()
        {
            base.Start();

            _parentCanvas = GetComponentInParent<Canvas>();
            if ( _parentCanvas != null )
                _parentCanvasRectTransform = _parentCanvas.transform as RectTransform;
        }

 private void Awake()
 {
     m_rectTransform = GetComponent<RectTransform>();
     SiblingGraphics.SetActive(true);
     m_parentCanvas = GetComponentInParent<Canvas>();
     m_itemsControl = GetComponentInParent<ItemsControl>();
     AwakeOverride();
 }

 public Rect GetCanvasRect(RectTransform t, Canvas c)
 {
   t.GetWorldCorners(this.m_WorldCorners);
   Transform component = c.GetComponent<Transform>();
   for (int index = 0; index < 4; ++index)
     this.m_CanvasCorners[index] = component.InverseTransformPoint(this.m_WorldCorners[index]);
   return new Rect(this.m_CanvasCorners[0].x, this.m_CanvasCorners[0].y, this.m_CanvasCorners[2].x - this.m_CanvasCorners[0].x, this.m_CanvasCorners[2].y - this.m_CanvasCorners[0].y);
 }

        void Awake()
        {
            _win = this.GetComponent<Canvas>();
            _label = this.GetComponentInChildren<Text>();
            _win.enabled = false;

            _yes = GameObject.Find("Yes").GetComponent<Button>();
        }

        private void FindCanvas()
        {
            if (!canvas)
                canvas = FindObjectOfType<Canvas>();

            if (!canvas)
                throw new InvalidOperationException("You need a canvas in your scene, or add code to create one here.");
        }