public void ChangeButtonColor(Event e)
 {
     // GUI lookup example
     Button button = GuiLookup.FindComponent<Button>(gameObject, "button1");
     if (null != button)
         button.Color = Color.green;
 }

	public void RemoveButtonColor(Event e)
	{
		// GUI lookup example
		Button button = GuiLookup.GetComponent("button1") as Button;
		if (null != button)
			button.Color = Color.white;
	}

        private void RollOverHandler(Event e)
        {
            if (e.Target != this) // skin
                return;

            /*_tween = new Sequence(
                Tween.New().SetOptions(
                    new TweenOption(TweenOptionType.Property, "Height"),
                    new TweenOption(TweenOptionType.Duration, 1f),
                    new TweenOption(TweenOptionType.Easer, (Tween.EasingFunction)Expo.EaseInOut),
                    new TweenOption(TweenOptionType.StartValueReader, new PropertyReader("Height")),
                    new TweenOption(TweenOptionType.EndValue, 400f),
                    new TweenOption(TweenOptionType.Target, this)
                    ),
                Tween.New().SetOptions(
                    new TweenOption(TweenOptionType.Property, "Width"),
                    new TweenOption(TweenOptionType.Duration, 1f),
                    new TweenOption(TweenOptionType.Easer, (Tween.EasingFunction)Expo.EaseInOut),
                    new TweenOption(TweenOptionType.StartValueReader, new PropertyReader("Width")),
                    new TweenOption(TweenOptionType.EndValue, 300f),
                    new TweenOption(TweenOptionType.Target, this)
                    )
                );
            _tween.Play();*/
        }

        private void MoveAreaMouseDownHandler(Event e)
        {
            //Debug.Log("Mouse down: " + e.Target);

            //if (e.Target != MoveArea)
            //    return;

            //Debug.Log("MoveAreaMouseDownHandler: " + e.Target);
            // Only allow dragging of pop-upped windows
            if (Enabled && IsPopUp)
            {
                e.CancelAndStopPropagation();
                // Calculate the mouse's offset in the window
                //offsetX = event.stageX - x;
                //offsetY = event.stageY - y;

                BringToFront();

                MouseEvent me = (MouseEvent) e;
                _offset = me.GlobalPosition.Subtract(Transform.Position);

                var sm = SystemEventDispatcher.Instance;
                sm.AddEventListener(MouseEvent.MOUSE_MOVE, MoveAreaMouseMoveHandler, EventPhase.CaptureAndTarget);
                sm.AddEventListener(MouseEvent.MOUSE_UP, MoveAreaMouseUpHandler, EventPhase.CaptureAndTarget);
                _cursorId = CursorManager.Instance.SetCursor(CursorType.Move);
            }
        }

	public void PaintButtonGreen(Event e)
	{
		// GUI lookup example
		Button button = GuiLookup.GetComponent("button1") as Button;
		if (null != button)
			button.Color = Color.green;
	}

        private void TimerHandler(Event e)
        {
            Callback(Lines[_count]);

            _count++;
            if (_count >= Lines.Length)
                _count = 0;
        }

    public void ClosingHandler(Event e)
    {
        Alert.Show("Combo box closing", string.Format(@"[{0}] received:

Type: {1}
Target: {2}
CurrentTarget: {3}", e.GetType(), e.Type, e.Target, e.CurrentTarget), AlertButtonFlag.Ok);
    }

 private void OnPauseChanged(Event e)
 {
     bool paused = (bool)((ValueEvent) e).Value;
     Debug.Log("OnPauseChanged. Paused: " + paused);
     if (paused)
         _timer.Stop();
     else
         _timer.Start();
 }

    public void ClickHandler(Event e)
    {
        //Debug.Log("ClickHandler: " + e.Target);
        Alert.Show("Event", string.Format(@"[{0}] received:

Type: {1}
Target: {2}
CurrentTarget: {3}", e.GetType(), e.Type, e.Target, e.CurrentTarget), AlertButtonFlag.Ok);
    }

 public void RemoveDialog(Event e)
 {
     Button button = e.Target as Button;
     if (button != null)
     {
         Dialog dialog = GuiLookup.FindParent<Dialog>(button);
         PopupManager.Instance.RemovePopup(dialog);
     }
 }

	public void Info(Event e)
	{
        Alert.Show(
            "Info",
            "This is the info message. The time is: " + DateTime.Now.ToLongTimeString(),
            AlertButtonFlag.Ok,
            new AlertOption(AlertOptionType.HeaderIcon, Resources.Load("Icons/information")),
            new AlertOption(AlertOptionType.AddedEffect, _alertEffect)
        );
	}

    private static void OnReset(Event e)
    {
        Debug.Log("OnReset");
        GameObject[] gameObjects = GameObject.FindGameObjectsWithTag("Cube");

        // destroy all Cubes
        foreach (GameObject o in gameObjects)
        {
            Destroy(o);
        }
    }

        private void IdleRollOverHandler(Event e)
        {
            if (e.Target != _component)
                return;
#if DEBUG
            if (DebugMode)
            {
                Debug.Log("IdleRollOverHandler");
            }
#endif
            SystemManager.Instance.MouseMoveSignal.Connect(MouseMoveSlot);
            //SystemManager.Instance.MouseUpSignal.Connect(MouseUpSlot);
        }

	public void ClickHandler(Event e)
	{
		//Debug.Log("ClickHandler: " + e.Target);
		Alert.Show("Event",
				   string.Format(@"[{0}] received:

Type: {1}
Target: {2}
CurrentTarget: {3}", e.GetType(), e.Type,
								 e.Target, e.CurrentTarget), AlertButtonFlag.Ok,
				   new AlertOption(AlertOptionType.HeaderIcon, Resources.Load("Icons/information")),
				   new AlertOption(AlertOptionType.AddedEffect, _alertEffect)
		);
	}

 private void KeyUpHandler(Event e)
 {
     KeyboardEvent ke = (KeyboardEvent)e;
     //Debug.Log("KeyUpHandler: " + ke.KeyCode);
     
     if (KeyCode.Escape == ke.KeyCode)
     {
         //Debug.Log("DialogCloseOnEsc->Escape");
         e.CancelAndStopPropagation();
         //PopupManager.Instance.RemovePopup(_dialog);
         if (Enabled)
             _dialog.ExecCallback("cancel");
     }
 }

        private void RollOverHandler(Event e)
        {
            if (e.Target != this) // skin
                return;

            //Debug.Log("RollOverHandler");
            //RollOverEffect.Target = this;
            //RollOverEffect.Play(_headerBackground);
            new Parallel(
                Tween.New().SetOptions(
                    new TweenOption(TweenOptionType.Property, "BackgroundColor"),
                    new TweenOption(TweenOptionType.Duration, 3f),
                    new TweenOption(TweenOptionType.Easer, (Tween.EasingFunction)Expo.EaseOut),
                    new TweenOption(TweenOptionType.StartValueReader, new PropertyReader("BackgroundColor")),
                    new TweenOption(TweenOptionType.EndValue, GetStyle("headerBackgroundRollOverColor")),
                    new TweenOption(TweenOptionType.Target, _headerBackground)
                    ),
                Tween.New().SetOptions(
                    new TweenOption(TweenOptionType.Property, "BackgroundColor"),
                    new TweenOption(TweenOptionType.Duration, 3f),
                    new TweenOption(TweenOptionType.Easer, (Tween.EasingFunction)Expo.EaseOut),
                    new TweenOption(TweenOptionType.StartValueReader, new PropertyReader("BackgroundColor")),
                    new TweenOption(TweenOptionType.EndValue, GetStyle("headerBackgroundRollOverColor")),
                    new TweenOption(TweenOptionType.Target, _controlBarBackground)
                    ),
                Tween.New().SetOptions(
                    new TweenOption(TweenOptionType.Property, "Rotation"),
                    new TweenOption(TweenOptionType.Duration, 2f),
                    new TweenOption(TweenOptionType.Easer, (Tween.EasingFunction)Expo.EaseInOut),
                    new TweenOption(TweenOptionType.StartValueReader, new PropertyReader("Rotation")),
                    new TweenOption(TweenOptionType.EndValue, 720f),
                    new TweenOption(TweenOptionType.Target, _backgroundImage)
                    )/*,
                Tween.New().SetOptions(
                   new TweenOption(TweenOptionType.Property, "Height"),
                   new TweenOption(TweenOptionType.Duration, 2f),
                   new TweenOption(TweenOptionType.Easer, (Tween.EasingFunction)Expo.EaseOut),
                   new TweenOption(TweenOptionType.StartValueReader, new PropertyReader("Height")),
                   new TweenOption(TweenOptionType.EndValue, 200f),
                   new TweenOption(TweenOptionType.Target, _controlBarBackground)
                )*/
                ).Play();
        }

        private void StartHandler(Event e)
        {
#if DEBUG
            if (DebugMode)
            {
                Debug.Log("StartHandler " + _component.Width + ", " + _component.Height);
            }
#endif
            if (null != _maskGraphics)
                return; // already masking this component

            _parent = _component.Parent ?? (_component is Stage ? _component : null);

            if (null == _parent)
                return; // we are not on the display list, so we have nothing to mask indeed

            _maskGraphics = new LoadingMaskAnimator {
                IncludeInLayout = false, 
                X = _component.X, 
                Y = _component.Y, 
                Width = _component.Width, 
                Height = _component.Height,
                //Bounds = (Rectangle) _component.Bounds.Clone() // BEWARE! This was the reference bug (without Clone())!!!!!!!!!
            };

            _parent.AddChild(_maskGraphics);

            LoadingEvent le = e as LoadingEvent;
            if (null != le)
                _maskGraphics.Message = le.Message;

            // critical!
            //_maskGraphics.Transform.Apply();
            _maskGraphics.InvalidateTransform();

            // subscribe to MOVE and RESIZE events of the component
            // we shall be levitating just over the component
            _component.AddEventListener(MoveEvent.MOVE, MoveHandler, EventPhase.Target);
            _component.AddEventListener(ResizeEvent.RESIZE, ResizeHandler, EventPhase.Target);

            _maskGraphics.Play();
        }

        /**
         *  
         */
        private void ResetCollectionChangeHandler(Event e)
        {
            //var ce = e as CollectionEvent;
            //if (ce != null)
            //{
            //    if (ce.Kind == CollectionEventKind.ADD ||
            //        ce.Kind == CollectionEventKind.REMOVE)
            //    {
            //        //Debug.Log("ResetCollectionChangeHandler");

            //        // force reset here so first/middle/last skins
            //        // get reassigned
            //        if (null != DataGroup)
            //        {
            //            DataGroup.Layout.UseVirtualLayout = true;
            //            DataGroup.Layout.UseVirtualLayout = false;
            //        }
            //    }
            //}
        }

        private void IdleRollOutHandler(Event e)
        {
            if (IsResizing)
                return;

            if (e.Target != _component)
                return;
#if DEBUG
            if (DebugMode)
            {
                Debug.Log("IdleRollOutHandler");
            }
#endif
            SystemManager.Instance.MouseMoveSignal.Disconnect(MouseMoveSlot);
            //SystemManager.Instance.MouseUpSignal.Disconnect(MouseUpSlot);

            /* Important (the source of the bug of right side cursor not dissapearing on roll out */
            HideCursor();
            if (_scanning)
            {
                StopScanning();
            }
        }

        private void OnChange(Event e)
        {
            HttpServiceProgressEvent inEvent = (HttpServiceProgressEvent) e;

            _dict[(HttpConnector) e.Target] = inEvent;

            HttpServiceProgressEvent pe = new HttpServiceProgressEvent(HttpServiceProgressEvent.PROGRESS_CHANGE);

            foreach (HttpServiceProgressEvent progressEvent in _dict.Values)
            {
                if (null == progressEvent)
                    continue;

                pe.Total += progressEvent.Total;
                pe.Active += progressEvent.Active;
                pe.Finished += progressEvent.Finished;
            }

            #if DEBUG
            if (DebugMode)
                Debug.Log("HttpServiceProgressAggregator: " + pe);
            #endif
            DispatchEvent(pe);
        }